## Uses of Class
org.hibernate.HibernateException

Packages that use HibernateException
org.hibernate: This package defines the central Hibernate APIs.
org.hibernate.action.internal
org.hibernate.action.spi
org.hibernate.bytecode.spi
org.hibernate.cache: This package defines API of the Hibernate second level cache service.
org.hibernate.cache.ehcache
org.hibernate.cache.internal
org.hibernate.cache.spi: Defines the Hibernate second level caching SPI.
org.hibernate.cache.spi.access: Defines contracts for transactional and concurrent access to cached `entity` and `collection` data.
org.hibernate.cache.spi.entry: This package defines formats for disassembled state kept in the second level cache.
org.hibernate.cfg: This package defines APIs for configuring Hibernate, and classes for building the Hibernate configuration-time metamodel.
org.hibernate.collection.internal
org.hibernate.collection.spi
org.hibernate.context
org.hibernate.context.internal
org.hibernate.context.spi
org.hibernate.criterion: A framework for defining restriction criteria and order criteria.
org.hibernate.dialect: This package abstracts the SQL dialect of the underlying database.
org.hibernate.dialect.lock
org.hibernate.ejb
org.hibernate.ejb.connection
org.hibernate.ejb.internal
org.hibernate.engine.internal
org.hibernate.engine.jdbc.internal
org.hibernate.engine.jdbc.internal.proxy
org.hibernate.engine.query.spi
org.hibernate.engine.spi
org.hibernate.engine.transaction.internal
org.hibernate.engine.transaction.internal.jdbc
org.hibernate.engine.transaction.internal.jta
org.hibernate.engine.transaction.spi
org.hibernate.envers
org.hibernate.envers.entities
org.hibernate.envers.entities.mapper.relation.lazy
org.hibernate.envers.exception
org.hibernate.envers.internal
org.hibernate.envers.reader
org.hibernate.event.internal: This package defines a default set of event listeners that implements the default behaviors of Hibernate.
org.hibernate.event.service.spi
org.hibernate.event.spi
org.hibernate.exception: This package is a fork of Apache commons-lang nestable exceptions.
org.hibernate.exception.spi
org.hibernate.hql.internal
org.hibernate.hql.internal.ast: An ANTLR-based parser for Hibernate Query Language.
org.hibernate.hql.internal.ast.exec
org.hibernate.hql.internal.classic: This package contains the Hibernate 2.x query parser which is being end-of-lifed.
org.hibernate.hql.spi
org.hibernate.id: This package contains internal implementation classes for the main API interfaces.
org.hibernate.id.enhanced
org.hibernate.internal: An internal package containing mostly implementations of central Hibernate APIs.
org.hibernate.internal.util: Internal utility classes.
org.hibernate.internal.util.beans
org.hibernate.internal.util.config
org.hibernate.jdbc: Essentially defines `Work`, `ReturningWork` and `Expectation` as well as some exceptions
org.hibernate.jmx: This package exposes a Hibernate instance via JMX.
org.hibernate.loader: This package defines functionality for processing JDBC result sets and returning complex graphs of persistent objects.
org.hibernate.loader.collection: This package defines collection initializers
org.hibernate.loader.criteria: This package defines the criteria query compiler and loader
org.hibernate.loader.custom: This package defines a framework for custom loaders that accept handwritten SQL
org.hibernate.loader.custom.sql
org.hibernate.loader.entity: This package defines entity loaders
org.hibernate.loader.hql: This package defines a loader for the AST-based query parser
org.hibernate.mapping: This package defines the Hibernate configuration-time metamodel.
org.hibernate.metadata: This package defines an API for accessing the Hibernate runtime metamodel.
org.hibernate.metamodel: NOTE: This package is currently unfinished and therefore considered experimental and unsupported.
org.hibernate.metamodel.relational: This package defines the metamodel of a relational database schema.
org.hibernate.metamodel.source
org.hibernate.metamodel.source.annotations
org.hibernate.persister.collection: This package abstracts the persistence mechanism for collections.
org.hibernate.persister.entity: This package abstracts persistence mechanisms for entities, and defines the Hibernate runtime metamodel.
org.hibernate.persister.internal
org.hibernate.persister.spi
org.hibernate.property: This package abstracts the notion of a "property" of an entity.
org.hibernate.proxy: This package defines a framework for lazy-initializing entity proxies.
org.hibernate.proxy.dom4j
org.hibernate.proxy.map
org.hibernate.proxy.pojo.javassist
org.hibernate.secure.internal
org.hibernate.service
org.hibernate.service.classloading.spi
org.hibernate.service.internal
org.hibernate.service.jdbc.connections.internal
org.hibernate.service.jdbc.dialect.internal
org.hibernate.service.jdbc.dialect.spi
org.hibernate.service.jndi
org.hibernate.service.jta.platform.spi
org.hibernate.service.spi
org.hibernate.sql.ordering.antlr
org.hibernate.testing.junit4
org.hibernate.tool
org.hibernate.tool.hbm2ddl: The `hbm2ddl` tool.
org.hibernate.transaction: This package abstracts the underlying transaction mechanism (JTA or JDBC) and provides strategies for obtaining application server `TransactionManager`s.
org.hibernate.tuple.component
org.hibernate.tuple.entity
org.hibernate.type: A Hibernate `Type` is a strategy for mapping a Java property type to a JDBC type or types.
org.hibernate.type.descriptor.java
org.hibernate.usertype: Interfaces for user-defined custom types.

Uses of HibernateException in org.hibernate

Subclasses of HibernateException in org.hibernate
`class` `AnnotationException` Annotation related exception.
`class` `CallbackException` Should be thrown by persistent objects from `Lifecycle` or `Interceptor` callbacks.
`class` `DuplicateMappingException` Raised whenever a duplicate for a certain type occurs.
`class` `InstantiationException` Thrown if Hibernate can't instantiate an entity or component class at runtime.
`class` `InvalidMappingException` Thrown when a mapping is found to be invalid.
`class` `JDBCException` Wraps an `SQLException`.
`class` `LazyInitializationException` Indicates access to unfetched data outside of a session context.
`class` `MappingException` An exception that usually occurs at configuration time, rather than runtime, as a result of something screwy in the O-R mappings.
`class` `MappingNotFoundException` Thrown when a resource for a mapping could not be found.
`class` `NonUniqueObjectException` This exception is thrown when an operation would break session-scoped identity.
`class` `NonUniqueResultException` Thrown when the application calls `Query.uniqueResult()` and the query returned more than one result.
`class` `ObjectDeletedException` Thrown when the user tries to do something illegal with a deleted object.
`class` `ObjectNotFoundException` Thrown when `Session.load()` fails to select a row with the given primary key (identifier value).
`class` `OptimisticLockException` Deprecated. Use `OptimisticEntityLockException` instead
`class` `PersistentObjectException` Thrown when the user passes a persistent instance to a `Session` method that expects a transient instance.
`class` `PessimisticLockException` Thrown when a pessimistic locking conflict occurs.
`class` `PropertyAccessException` A problem occurred accessing a property of an instance of a persistent class by reflection, or via CGLIB.
`class` `PropertyNotFoundException` Indicates that an expected getter or setter method could not be found on a class.
`class` `PropertyValueException` Thrown when the (illegal) value of a property can not be persisted.
`class` `QueryException` A problem occurred translating a Hibernate query to SQL due to invalid query syntax, etc.
`class` `QueryParameterException` Parameter invalid or not found in the query
`class` `QueryTimeoutException` Thrown when a database query timeout occurs.
`class` `ResourceClosedException` Indicates an attempt was made to use a closed resource (Session, SessionFactory, etc).
`class` `SessionException` Thrown when the user calls a method of a `Session` that is in an inappropriate state for the given call (for example, the the session is closed or disconnected).
`class` `StaleObjectStateException` A `StaleStateException` that carries information about a particular entity instance that was the source of the failure.
`class` `StaleStateException` Thrown when a version number or timestamp check failed, indicating that the `Session` contained stale data (when using long transactions with versioning).
`class` `TransactionException` Indicates that a transaction could not be begun, committed or rolled back.
`class` `TransientObjectException` Thrown when the user passes a transient instance to a `Session` method that expects a persistent instance.
`class` `TransientPropertyValueException` Thrown when a property cannot be persisted because it is an association with a transient unsaved entity instance.
`class` `TypeMismatchException` Used when a user provided type does not match the expected one
`class` `UnknownProfileException` Used to indicate a request against an unknown profile name.
`class` `UnresolvableObjectException` Thrown when Hibernate could not resolve an object by id, especially when loading an association.
`class` `WrongClassException` Thrown when `Session.load()` selects a row with the given primary key (identifier value) but the row's discriminator value specifies a subclass that is not assignable to the class requested by the user.

Methods in org.hibernate that throw HibernateException
`void` `ScrollableResults.afterLast()` Go to a location just after the last result
`void` `ScrollableResults.beforeFirst()` Go to a location just before first result (this is the initial location)
`void` `Session.cancelQuery()` Cancel the execution of the current query.
`Connection` `Session.close()` End the session by releasing the JDBC connection and cleaning up.
`void` `SessionFactory.close()` Destroy this `SessionFactory` and release all resources (caches, connection pools, etc).
`void` `ScrollableResults.close()` Release resources immediately.
`static void` `Hibernate.close(Iterator iterator)` Close an `Iterator` created by `iterate()` immediately, instead of waiting until the session is closed or disconnected.
`Criteria` `Criteria.createAlias(String associationPath, String alias)` Join an association, assigning an alias to the joined association.
`Criteria` `Criteria.createAlias(String associationPath, String alias, int joinType)` Deprecated. use `Criteria.createAlias(String, String, org.hibernate.sql.JoinType)`
`Criteria` `Criteria.createAlias(String associationPath, String alias, int joinType, Criterion withClause)` Deprecated. use `Criteria.createAlias(String, String, JoinType, Criterion)`
`Criteria` `Criteria.createAlias(String associationPath, String alias, JoinType joinType)` Join an association using the specified join-type, assigning an alias to the joined association.
`Criteria` `Criteria.createAlias(String associationPath, String alias, JoinType joinType, Criterion withClause)` Join an association using the specified join-type, assigning an alias to the joined association.
`Criteria` `Criteria.createCriteria(String associationPath)` Create a new `Criteria`, "rooted" at the associated entity.
`Criteria` `Criteria.createCriteria(String associationPath, int joinType)` Deprecated. use `Criteria.createAlias(String, String, org.hibernate.sql.JoinType)`
`Criteria` `Criteria.createCriteria(String associationPath, JoinType joinType)` Create a new `Criteria`, "rooted" at the associated entity, using the specified join type.
`Criteria` `Criteria.createCriteria(String associationPath, String alias)` Create a new `Criteria`, "rooted" at the associated entity, assigning the given alias.
`Criteria` `Criteria.createCriteria(String associationPath, String alias, int joinType)` Deprecated. use `Criteria.createCriteria(String, org.hibernate.sql.JoinType)`
`Criteria` `Criteria.createCriteria(String associationPath, String alias, int joinType, Criterion withClause)` Deprecated. use `Criteria.createCriteria(String, String, org.hibernate.sql.JoinType, org.hibernate.criterion.Criterion)`
`Criteria` `Criteria.createCriteria(String associationPath, String alias, JoinType joinType)` Create a new `Criteria`, "rooted" at the associated entity, assigning the given alias and using the specified join type.
`Criteria` `Criteria.createCriteria(String associationPath, String alias, JoinType joinType, Criterion withClause)` Create a new `Criteria`, "rooted" at the associated entity, assigning the given alias and using the specified join type.

`

`<T> T`

`

`Session.doReturningWork(ReturningWork<T> work)`
Controller for allowing users to perform JDBC related work using the Connection managed by this Session.

`void` `Session.doWork(Work work)` Controller for allowing users to perform JDBC related work using the Connection managed by this Session.
`void` `SessionFactory.evict(Class persistentClass)` Deprecated. Use `Cache.evictEntityRegion(Class)` accessed through `SessionFactory.getCache()` instead.
`void` `SessionFactory.evict(Class persistentClass, Serializable id)` Deprecated. Use `Cache.containsEntity(Class, Serializable)` accessed through `SessionFactory.getCache()` instead.
`void` `SessionFactory.evictCollection(String roleName)` Deprecated. Use `Cache.evictCollectionRegion(String)` accessed through `SessionFactory.getCache()` instead.
`void` `SessionFactory.evictCollection(String roleName, Serializable id)` Deprecated. Use `Cache.evictCollection(String,Serializable)` accessed through `SessionFactory.getCache()` instead.
`void` `SessionFactory.evictEntity(String entityName)` Deprecated. Use `Cache.evictEntityRegion(String)` accessed through `SessionFactory.getCache()` instead.
`void` `SessionFactory.evictEntity(String entityName, Serializable id)` Deprecated. Use `Cache.evictEntity(String,Serializable)` accessed through `SessionFactory.getCache()` instead.
`void` `SessionFactory.evictQueries()` Deprecated. Use `Cache.evictQueryRegions()` accessed through `SessionFactory.getCache()` instead.
`void` `SessionFactory.evictQueries(String cacheRegion)` Deprecated. Use `Cache.evictQueryRegion(String)` accessed through `SessionFactory.getCache()` instead.
`int` `Query.executeUpdate()` Execute the update or delete statement.
`boolean` `ScrollableResults.first()` Go to the first result
`void` `Session.flush()` Force this session to flush.
`Object[]` `ScrollableResults.get()` Get the current row of results
`Object` `ScrollableResults.get(int i)` Get the `i`th object in the current row of results, without initializing any other results in the row.
`BigDecimal` `ScrollableResults.getBigDecimal(int col)` Convenience method to read a `big_decimal`
`BigInteger` `ScrollableResults.getBigInteger(int col)` Convenience method to read a `big_integer`
`byte[]` `ScrollableResults.getBinary(int col)` Convenience method to read a `binary`
`Blob` `ScrollableResults.getBlob(int col)` Convenience method to read a `blob`
`Boolean` `ScrollableResults.getBoolean(int col)` Convenience method to read a `boolean`
`Byte` `ScrollableResults.getByte(int col)` Convenience method to read a `byte`
`Calendar` `ScrollableResults.getCalendar(int col)` Convenience method to read a `calendar` or `calendar_date`
`Character` `ScrollableResults.getCharacter(int col)` Convenience method to read a `character`
`Clob` `ScrollableResults.getClob(int col)` Convenience method to read a `clob`
`Session` `SessionFactory.getCurrentSession()` Obtains the current session.
`Date` `ScrollableResults.getDate(int col)` Convenience method to read a `date`, `time` or `timestamp`
`Double` `ScrollableResults.getDouble(int col)` Convenience method to read a `double`
`FilterDefinition` `SessionFactory.getFilterDefinition(String filterName)` Obtain the definition of a filter by name.
`Float` `ScrollableResults.getFloat(int col)` Convenience method to read a `float`
`Integer` `ScrollableResults.getInteger(int col)` Convenience method to read an `integer`
`Locale` `ScrollableResults.getLocale(int col)` Convenience method to read a `locale`
`Long` `ScrollableResults.getLong(int col)` Convenience method to read a `long`
`String[]` `Query.getNamedParameters()` Return the names of all named parameters of the query.
`String[]` `Query.getReturnAliases()` Return the HQL select clause aliases (if any)
`Type[]` `Query.getReturnTypes()` Return the Hibernate types of the query result set.
`int` `ScrollableResults.getRowNumber()` Get the current location in the result set.
`Short` `ScrollableResults.getShort(int col)` Convenience method to read a `short`
`String` `ScrollableResults.getString(int col)` Convenience method to read a `string`
`String` `ScrollableResults.getText(int col)` Convenience method to read `text`
`TimeZone` `ScrollableResults.getTimeZone(int col)` Convenience method to read a `timezone`
`static void` `Hibernate.initialize(Object proxy)` Force initialization of a proxy or persistent collection.
`boolean` `Session.isDirty()` Does this session contain any changes which must be synchronized with the database? In other words, would any DML operations be executed if we flushed this session?
`boolean` `ScrollableResults.isFirst()` Is this the first result?
`boolean` `ScrollableResults.isLast()` Is this the last result?
`Iterator` `Query.iterate()` Return the query results as an `Iterator`.
`boolean` `ScrollableResults.last()` Go to the last result
`List` `Query.list()` Return the query results as a `List`.
`List` `Criteria.list()` Get the results.
`void` `Session.LockRequest.lock(Object object)`
`void` `Session.LockRequest.lock(String entityName, Object object)`
`boolean` `ScrollableResults.next()` Advance to the next result
`Session` `SessionFactory.openSession()` Open a `Session`.
`boolean` `ScrollableResults.previous()` Retreat to the previous result
`void` `Transaction.registerSynchronization(Synchronization synchronization)` Register a user synchronization callback for this transaction.
`ScrollableResults` `Query.scroll()` Return the query results as `ScrollableResults`.
`ScrollableResults` `Criteria.scroll()` Get the results as an instance of `ScrollableResults`
`boolean` `ScrollableResults.scroll(int i)` Scroll an arbitrary number of locations
`ScrollableResults` `Query.scroll(ScrollMode scrollMode)` Return the query results as `ScrollableResults`.
`ScrollableResults` `Criteria.scroll(ScrollMode scrollMode)` Get the results as an instance of `ScrollableResults` based on the given scroll mode.
`Criteria` `Criteria.setFetchMode(String associationPath, FetchMode mode)` Specify an association fetching strategy for an association or a collection of values.
`Query` `Query.setParameter(int position, Object val)` Bind a value to a JDBC-style query parameter.
`Query` `Query.setParameter(String name, Object val)` Bind a value to a named query parameter.
`Query` `Query.setParameterList(String name, Collection vals)` Bind multiple values to a named query parameter.
`Query` `Query.setParameterList(String name, Collection vals, Type type)` Bind multiple values to a named query parameter.
`Query` `Query.setParameterList(String name, Object[] vals)` Bind multiple values to a named query parameter.
`Query` `Query.setParameterList(String name, Object[] vals, Type type)` Bind multiple values to a named query parameter.
`Query` `Query.setParameters(Object[] values, Type[] types)` Bind values and types to positional parameters.
`Query` `Query.setProperties(Map bean)` Bind the values of the given Map for each named parameters of the query, matching key names with parameter names and mapping value types to Hibernate types using hueristics.
`Query` `Query.setProperties(Object bean)` Bind the property values of the given bean to named parameters of the query, matching property names with parameter names and mapping property types to Hibernate types using hueristics.
`boolean` `ScrollableResults.setRowNumber(int rowNumber)` Set the current location in the result set, numbered from either the first row (row number `0`), or the last row (row number `-1`).
`Object` `Query.uniqueResult()` Convenience method to return a single instance that matches the query, or null if the query returns no results.
`Object` `Criteria.uniqueResult()` Convenience method to return a single instance that matches the query, or null if the query returns no results.
`void` `Filter.validate()` Perform validation of the filter state.

Uses of HibernateException in org.hibernate.action.internal

Methods in org.hibernate.action.internal that throw HibernateException
`void` `BulkOperationCleanupAction.beforeExecutions()`
`void` `EntityDeleteAction.doAfterTransactionCompletion(boolean success, SessionImplementor session)`
`void` `EntityInsertAction.doAfterTransactionCompletion(boolean success, SessionImplementor session)`
`void` `EntityDeleteAction.execute()`
`void` `CollectionRecreateAction.execute()`
`void` `CollectionRemoveAction.execute()`
`void` `EntityInsertAction.execute()`
`void` `EntityIdentityInsertAction.execute()`
`void` `EntityUpdateAction.execute()`
`void` `BulkOperationCleanupAction.execute()`
`void` `CollectionUpdateAction.execute()`

Constructors in org.hibernate.action.internal that throw HibernateException
`EntityIdentityInsertAction(Object[] state, Object instance, EntityPersister persister, boolean isVersionIncrementDisabled, SessionImplementor session, boolean isDelayed)`
`EntityInsertAction(Serializable id, Object[] state, Object instance, Object version, EntityPersister persister, boolean isVersionIncrementDisabled, SessionImplementor session)`
`EntityUpdateAction(Serializable id, Object[] state, int[] dirtyProperties, boolean hasDirtyCollection, Object[] previousState, Object previousVersion, Object nextVersion, Object instance, Object rowId, EntityPersister persister, SessionImplementor session)`

Uses of HibernateException in org.hibernate.action.spi

Methods in org.hibernate.action.spi that throw HibernateException
`void` `Executable.beforeExecutions()` Called before executing any actions.
`void` `Executable.execute()` Execute this action

Uses of HibernateException in org.hibernate.bytecode.spi

Subclasses of HibernateException in org.hibernate.bytecode.spi
`class` `NotInstrumentedException`

Uses of HibernateException in org.hibernate.cache

Subclasses of HibernateException in org.hibernate.cache
`class` `CacheException` Something went wrong in the cache
`class` `NoCacheRegionFactoryAvailableException` Implementation of NoCacheRegionFactoryAvailableException.

Uses of HibernateException in org.hibernate.cache.ehcache

Methods in org.hibernate.cache.ehcache with parameters of type HibernateException
`void` `EhCacheMessageLogger_$logger.namedQueryError(String arg0, HibernateException arg1)`
`void` `EhCacheMessageLogger_$logger.unableToCloseSession(HibernateException arg0)`
`void` `EhCacheMessageLogger_$logger.unableToCloseSessionButSwallowingError(HibernateException arg0)`
`void` `EhCacheMessageLogger_$logger.unableToConfigureSqlExceptionConverter(HibernateException arg0)`
`void` `EhCacheMessageLogger_$logger.unableToCreateProxyFactory(String arg0, HibernateException arg1)`
`void` `EhCacheMessageLogger_$logger.unableToLoadCommand(HibernateException arg0)`
`void` `EhCacheMessageLogger_$logger.unableToSynchronizeDatabaseStateWithSession(HibernateException arg0)`

Uses of HibernateException in org.hibernate.cache.internal

Methods in org.hibernate.cache.internal that throw HibernateException
`List` `StandardQueryCache.get(QueryKey key, Type[] returnTypes, boolean isNaturalKeyLookup, Set spaces, SessionImplementor session)`
`QueryCache` `StandardQueryCacheFactory.getQueryCache(String regionName, UpdateTimestampsCache updateTimestampsCache, Settings settings, Properties props)`
`boolean` `StandardQueryCache.put(QueryKey key, Type[] returnTypes, List result, boolean isNaturalKeyLookup, SessionImplementor session)`

Constructors in org.hibernate.cache.internal that throw HibernateException
`StandardQueryCache(Settings settings, Properties props, UpdateTimestampsCache updateTimestampsCache, String regionName)`

Uses of HibernateException in org.hibernate.cache.spi

Methods in org.hibernate.cache.spi that throw HibernateException
`List` `QueryCache.get(QueryKey key, Type[] returnTypes, boolean isNaturalKeyLookup, Set spaces, SessionImplementor session)`
`QueryCache` `QueryCacheFactory.getQueryCache(String regionName, UpdateTimestampsCache updateTimestampsCache, Settings settings, Properties props)`
`boolean` `UpdateTimestampsCache.isUpToDate(Set spaces, Long timestamp)`
`boolean` `QueryCache.put(QueryKey key, Type[] returnTypes, List result, boolean isNaturalKeyLookup, SessionImplementor session)`

Constructors in org.hibernate.cache.spi that throw HibernateException
`UpdateTimestampsCache(Settings settings, Properties props)`
`UpdateTimestampsCache(Settings settings, Properties props, SessionFactoryImplementor factory)`

Uses of HibernateException in org.hibernate.cache.spi.access

Subclasses of HibernateException in org.hibernate.cache.spi.access
`class` `UnknownAccessTypeException`

Uses of HibernateException in org.hibernate.cache.spi.entry

Methods in org.hibernate.cache.spi.entry that throw HibernateException
`Object[]` `CacheEntry.assemble(Object instance, Serializable id, EntityPersister persister, Interceptor interceptor, EventSource session)`

Constructors in org.hibernate.cache.spi.entry that throw HibernateException
`CacheEntry(Object[] state, EntityPersister persister, boolean unfetched, Object version, SessionImplementor session, Object owner)`

Uses of HibernateException in org.hibernate.cfg

Subclasses of HibernateException in org.hibernate.cfg
`class` `NotYetImplementedException` Mapping not yet implemented
`class` `RecoverableException` Should neven be exposed to the client An exception that wrap an underlying exception whith the hope subsequent processing will recover from it.

Methods in org.hibernate.cfg that throw HibernateException
`SessionFactory` `Configuration.buildSessionFactory()` Deprecated. Use `Configuration.buildSessionFactory(ServiceRegistry)` instead
`SessionFactory` `Configuration.buildSessionFactory(ServiceRegistry serviceRegistry)` Create a `SessionFactory` using the properties and mappings in this configuration.
`Settings` `Configuration.buildSettings(Properties props, ServiceRegistry serviceRegistry)`
`AnnotationConfiguration` `AnnotationConfiguration.configure()` Deprecated.
`Configuration` `Configuration.configure()` Use the mappings and properties specified in an application resource named `hibernate.cfg.xml`.
`AnnotationConfiguration` `AnnotationConfiguration.configure(Document document)` Deprecated.
`Configuration` `Configuration.configure(Document document)` Use the mappings and properties specified in the given XML document.
`AnnotationConfiguration` `AnnotationConfiguration.configure(File configFile)` Deprecated.
`Configuration` `Configuration.configure(File configFile)` Use the mappings and properties specified in the given application file.
`AnnotationConfiguration` `AnnotationConfiguration.configure(String resource)` Deprecated.
`Configuration` `Configuration.configure(String resource)` Use the mappings and properties specified in the given application resource.
`AnnotationConfiguration` `AnnotationConfiguration.configure(URL url)` Deprecated.
`Configuration` `Configuration.configure(URL url)` Use the mappings and properties specified in the given document.
`protected AnnotationConfiguration` `AnnotationConfiguration.doConfigure(org.dom4j.Document doc)` Deprecated.
`protected Configuration` `Configuration.doConfigure(org.dom4j.Document doc)` Parse a dom4j document conforming to the Hibernate Configuration DTD (`hibernate-configuration-3.0.dtd`) and use its information to configure this `Configuration`'s state
`protected AnnotationConfiguration` `AnnotationConfiguration.doConfigure(InputStream stream, String resourceName)` Deprecated.
`protected Configuration` `Configuration.doConfigure(InputStream stream, String resourceName)` Configure this configuration's state from the contents of the given input stream.
`String[]` `Configuration.generateDropSchemaScript(Dialect dialect)` Generate DDL for dropping tables
`String[]` `Configuration.generateSchemaCreationScript(Dialect dialect)`
`String[]` `Configuration.generateSchemaUpdateScript(Dialect dialect, DatabaseMetadata databaseMetadata)`
`protected InputStream` `Configuration.getConfigurationInputStream(String resource)` Get the configuration file as an `InputStream`.
`void` `Configuration.validateSchema(Dialect dialect, DatabaseMetadata databaseMetadata)`

Uses of HibernateException in org.hibernate.collection.internal

Methods in org.hibernate.collection.internal that throw HibernateException
`void` `PersistentIdentifierBag.afterRowInsert(CollectionPersister persister, Object entry, int i)`
`void` `AbstractPersistentCollection.afterRowInsert(CollectionPersister persister, Object entry, int i)` Called after inserting a row, to fetch the natively generated id
`Serializable` `PersistentArrayHolder.disassemble(CollectionPersister persister)`
`Serializable` `PersistentMapElementHolder.disassemble(CollectionPersister persister)`
`Serializable` `PersistentMap.disassemble(CollectionPersister persister)`
`Serializable` `PersistentList.disassemble(CollectionPersister persister)`
`Serializable` `PersistentBag.disassemble(CollectionPersister persister)`
`Serializable` `PersistentListElementHolder.disassemble(CollectionPersister persister)`
`Serializable` `PersistentSet.disassemble(CollectionPersister persister)`
`Serializable` `PersistentIdentifierBag.disassemble(CollectionPersister persister)`
`Serializable` `PersistentElementHolder.disassemble(CollectionPersister persister)`
`boolean` `PersistentIndexedElementHolder.equalsSnapshot(CollectionPersister persister)`
`boolean` `PersistentArrayHolder.equalsSnapshot(CollectionPersister persister)`
`boolean` `PersistentMap.equalsSnapshot(CollectionPersister persister)`
`boolean` `PersistentList.equalsSnapshot(CollectionPersister persister)`
`boolean` `PersistentBag.equalsSnapshot(CollectionPersister persister)`
`boolean` `PersistentSet.equalsSnapshot(CollectionPersister persister)`
`boolean` `PersistentIdentifierBag.equalsSnapshot(CollectionPersister persister)`
`boolean` `PersistentElementHolder.equalsSnapshot(CollectionPersister persister)`
`void` `AbstractPersistentCollection.forceInitialization()` To be called internally by the session, forcing immediate initialization.
`Iterator` `PersistentIndexedElementHolder.getDeletes(CollectionPersister persister, boolean indexIsFormula)`
`Iterator` `PersistentArrayHolder.getDeletes(CollectionPersister persister, boolean indexIsFormula)`
`Iterator` `PersistentMap.getDeletes(CollectionPersister persister, boolean indexIsFormula)`
`Iterator` `PersistentList.getDeletes(CollectionPersister persister, boolean indexIsFormula)`
`Iterator` `PersistentBag.getDeletes(CollectionPersister persister, boolean indexIsFormula)`
`Iterator` `PersistentSet.getDeletes(CollectionPersister persister, boolean indexIsFormula)`
`Iterator` `PersistentIdentifierBag.getDeletes(CollectionPersister persister, boolean indexIsFormula)`
`Iterator` `PersistentElementHolder.getDeletes(CollectionPersister persister, boolean indexIsFormula)`
`protected static Collection` `AbstractPersistentCollection.getOrphans(Collection oldElements, Collection currentElements, String entityName, SessionImplementor session)` Given a collection of entity instances that used to belong to the collection, and a collection of instances that currently belong, return a collection of orphans
`Collection` `PersistentIndexedElementHolder.getOrphans(Serializable snapshot, String entityName)`
`Collection` `PersistentArrayHolder.getOrphans(Serializable snapshot, String entityName)`
`Collection` `PersistentMap.getOrphans(Serializable snapshot, String entityName)`
`Collection` `PersistentList.getOrphans(Serializable snapshot, String entityName)`
`Collection` `PersistentBag.getOrphans(Serializable snapshot, String entityName)`
`Collection` `PersistentSet.getOrphans(Serializable snapshot, String entityName)`
`Collection` `PersistentIdentifierBag.getOrphans(Serializable snapshot, String entityName)`
`Collection` `PersistentElementHolder.getOrphans(Serializable snapshot, String entityName)`
`abstract Collection` `AbstractPersistentCollection.getOrphans(Serializable snapshot, String entityName)` get all "orphaned" elements
`Serializable` `PersistentIndexedElementHolder.getSnapshot(CollectionPersister persister)`
`Serializable` `PersistentArrayHolder.getSnapshot(CollectionPersister persister)`
`Serializable` `PersistentMap.getSnapshot(CollectionPersister persister)`
`Serializable` `PersistentList.getSnapshot(CollectionPersister persister)`
`Serializable` `PersistentBag.getSnapshot(CollectionPersister persister)`
`Serializable` `PersistentSet.getSnapshot(CollectionPersister persister)`
`Serializable` `PersistentIdentifierBag.getSnapshot(CollectionPersister persister)`
`Serializable` `PersistentElementHolder.getSnapshot(CollectionPersister persister)`
`static void` `AbstractPersistentCollection.identityRemove(Collection list, Object object, String entityName, SessionImplementor session)`
`void` `PersistentArrayHolder.initializeFromCache(CollectionPersister persister, Serializable disassembled, Object owner)`
`void` `PersistentMapElementHolder.initializeFromCache(CollectionPersister persister, Serializable disassembled, Object owner)`
`void` `PersistentMap.initializeFromCache(CollectionPersister persister, Serializable disassembled, Object owner)`
`void` `PersistentList.initializeFromCache(CollectionPersister persister, Serializable disassembled, Object owner)`
`void` `PersistentBag.initializeFromCache(CollectionPersister persister, Serializable disassembled, Object owner)`
`void` `PersistentListElementHolder.initializeFromCache(CollectionPersister persister, Serializable disassembled, Object owner)`
`void` `PersistentSet.initializeFromCache(CollectionPersister persister, Serializable disassembled, Object owner)`
`void` `PersistentIdentifierBag.initializeFromCache(CollectionPersister persister, Serializable disassembled, Object owner)`
`void` `PersistentElementHolder.initializeFromCache(CollectionPersister persister, Serializable disassembled, Object owner)`
`boolean` `PersistentIndexedElementHolder.needsInserting(Object entry, int i, Type elementType)`
`boolean` `PersistentArrayHolder.needsInserting(Object entry, int i, Type elemType)`
`boolean` `PersistentMap.needsInserting(Object entry, int i, Type elemType)`
`boolean` `PersistentList.needsInserting(Object entry, int i, Type elemType)`
`boolean` `PersistentBag.needsInserting(Object entry, int i, Type elemType)`
`boolean` `PersistentSet.needsInserting(Object entry, int i, Type elemType)`
`boolean` `PersistentIdentifierBag.needsInserting(Object entry, int i, Type elemType)`
`boolean` `PersistentElementHolder.needsInserting(Object entry, int i, Type elementType)`
`boolean` `PersistentIndexedElementHolder.needsUpdating(Object entry, int i, Type elementType)`
`boolean` `PersistentArrayHolder.needsUpdating(Object entry, int i, Type elemType)`
`boolean` `PersistentMap.needsUpdating(Object entry, int i, Type elemType)`
`boolean` `PersistentList.needsUpdating(Object entry, int i, Type elemType)`
`boolean` `PersistentIdentifierBag.needsUpdating(Object entry, int i, Type elemType)`
`boolean` `PersistentElementHolder.needsUpdating(Object entry, int i, Type elementType)`
`void` `PersistentIdentifierBag.preInsert(CollectionPersister persister)`
`void` `AbstractPersistentCollection.preInsert(CollectionPersister persister)` Called before inserting rows, to ensure that any surrogate keys are fully generated
`Object` `PersistentIndexedElementHolder.readFrom(ResultSet rs, CollectionPersister persister, CollectionAliases descriptor, Object owner)`
`Object` `PersistentArrayHolder.readFrom(ResultSet rs, CollectionPersister persister, CollectionAliases descriptor, Object owner)`
`Object` `PersistentMap.readFrom(ResultSet rs, CollectionPersister persister, CollectionAliases descriptor, Object owner)`
`Object` `PersistentList.readFrom(ResultSet rs, CollectionPersister persister, CollectionAliases descriptor, Object owner)`
`Object` `PersistentBag.readFrom(ResultSet rs, CollectionPersister persister, CollectionAliases descriptor, Object owner)`
`Object` `PersistentSet.readFrom(ResultSet rs, CollectionPersister persister, CollectionAliases descriptor, Object owner)`
`Object` `PersistentIdentifierBag.readFrom(ResultSet rs, CollectionPersister persister, CollectionAliases descriptor, Object owner)`
`Object` `PersistentElementHolder.readFrom(ResultSet rs, CollectionPersister persister, CollectionAliases descriptor, Object owner)`
`boolean` `AbstractPersistentCollection.setCurrentSession(SessionImplementor session)` Associate the collection with the given session.
`protected Serializable` `PersistentSortedMap.snapshot(BasicCollectionPersister persister, EntityMode entityMode)`
`protected Serializable` `PersistentSortedSet.snapshot(BasicCollectionPersister persister, EntityMode entityMode)`

Constructors in org.hibernate.collection.internal that throw HibernateException
`PersistentArrayHolder(SessionImplementor session, CollectionPersister persister)`
`PersistentElementHolder(SessionImplementor session, CollectionPersister persister, Serializable key)`
`PersistentIndexedElementHolder(SessionImplementor session, CollectionPersister persister, Serializable key)`
`PersistentListElementHolder(SessionImplementor session, CollectionPersister persister, Serializable key)`
`PersistentMapElementHolder(SessionImplementor session, CollectionPersister persister, Serializable key)`

Uses of HibernateException in org.hibernate.collection.spi

Methods in org.hibernate.collection.spi that throw HibernateException
`void` `PersistentCollection.afterRowInsert(CollectionPersister persister, Object entry, int i)` Called after inserting a row, to fetch the natively generated id
`Serializable` `PersistentCollection.disassemble(CollectionPersister persister)` Disassemble the collection, ready for the cache
`boolean` `PersistentCollection.equalsSnapshot(CollectionPersister persister)` Does the current state exactly match the snapshot?
`void` `PersistentCollection.forceInitialization()` To be called internally by the session, forcing immediate initialization.
`Iterator` `PersistentCollection.getDeletes(CollectionPersister persister, boolean indexIsFormula)` Get all the elements that need deleting
`Collection` `PersistentCollection.getOrphans(Serializable snapshot, String entityName)` get all "orphaned" elements
`Serializable` `PersistentCollection.getSnapshot(CollectionPersister persister)` Return a new snapshot of the current state of the collection
`void` `PersistentCollection.initializeFromCache(CollectionPersister persister, Serializable disassembled, Object owner)` Read the state of the collection from a disassembled cached value
`boolean` `PersistentCollection.needsInserting(Object entry, int i, Type elemType)` Do we need to insert this element?
`boolean` `PersistentCollection.needsUpdating(Object entry, int i, Type elemType)` Do we need to update this element?
`void` `PersistentCollection.preInsert(CollectionPersister persister)` Called before inserting rows, to ensure that any surrogate keys are fully generated
`Object` `PersistentCollection.readFrom(ResultSet rs, CollectionPersister role, CollectionAliases descriptor, Object owner)` Read a row from the JDBC result set
`boolean` `PersistentCollection.setCurrentSession(SessionImplementor session)` Associate the collection with the given session.

Uses of HibernateException in org.hibernate.context

Subclasses of HibernateException in org.hibernate.context
`class` `TenantIdentifierMismatchException` Indicates that tenant identifiers did not match in cases where `CurrentTenantIdentifierResolver.validateExistingCurrentSessions()` returns `true` and there is a mismatch found.

Uses of HibernateException in org.hibernate.context.internal

Methods in org.hibernate.context.internal that throw HibernateException
`Session` `ThreadLocalSessionContext.currentSession()`
`Session` `JTASessionContext.currentSession()`

Uses of HibernateException in org.hibernate.context.spi

Methods in org.hibernate.context.spi that throw HibernateException
`Session` `CurrentSessionContext.currentSession()` Retrieve the current session according to the scoping defined by this implementation.

Uses of HibernateException in org.hibernate.criterion

Methods in org.hibernate.criterion that throw HibernateException
`protected void` `Example.addComponentTypedValues(String path, Object component, CompositeType type, List list, Criteria criteria, CriteriaQuery criteriaQuery)`
`protected void` `Example.appendComponentCondition(String path, Object component, CompositeType type, Criteria criteria, CriteriaQuery criteriaQuery, StringBuilder buf)`
`protected void` `Example.appendPropertyCondition(String propertyName, Object propertyValue, Criteria criteria, CriteriaQuery cq, StringBuilder buf)`
`DetachedCriteria` `DetachedCriteria.createAlias(String associationPath, String alias)`
`DetachedCriteria` `DetachedCriteria.createAlias(String associationPath, String alias, int joinType)` Deprecated. use `DetachedCriteria.createAlias(String, String, JoinType)`
`DetachedCriteria` `DetachedCriteria.createAlias(String associationPath, String alias, int joinType, Criterion withClause)` Deprecated. use `DetachedCriteria.createAlias(String, String, JoinType, Criterion)`
`DetachedCriteria` `DetachedCriteria.createAlias(String associationPath, String alias, JoinType joinType)`
`DetachedCriteria` `DetachedCriteria.createAlias(String associationPath, String alias, JoinType joinType, Criterion withClause)`
`DetachedCriteria` `DetachedCriteria.createCriteria(String associationPath)`
`DetachedCriteria` `DetachedCriteria.createCriteria(String associationPath, int joinType)` Deprecated. use `DetachedCriteria.createCriteria(String, JoinType)`
`DetachedCriteria` `DetachedCriteria.createCriteria(String associationPath, JoinType joinType)`
`DetachedCriteria` `DetachedCriteria.createCriteria(String associationPath, String alias)`
`DetachedCriteria` `DetachedCriteria.createCriteria(String associationPath, String alias, int joinType)` Deprecated. use `DetachedCriteria.createCriteria(String, String, JoinType)`
`DetachedCriteria` `DetachedCriteria.createCriteria(String associationPath, String alias, int joinType, Criterion withClause)` Deprecated. use `DetachedCriteria.createCriteria(String, String, JoinType, Criterion)`
`DetachedCriteria` `DetachedCriteria.createCriteria(String associationPath, String alias, JoinType joinType)`
`DetachedCriteria` `DetachedCriteria.createCriteria(String associationPath, String alias, JoinType joinType, Criterion withClause)`
`String[]` `CriteriaQuery.findColumns(String propertyPath, Criteria criteria)` Get the names of the columns mapped by a property path; if the property path is not found in criteria, try the "outer" query.
`String` `CriteriaQuery.getColumn(Criteria criteria, String propertyPath)` Get the names of the columns mapped by a property path, ignoring projection aliases
`String[]` `CriteriaQuery.getColumns(String propertyPath, Criteria criteria)` Get the names of the columns mapped by a property path, ignoring projection aliases
`String[]` `CriteriaQuery.getColumnsUsingProjection(Criteria criteria, String propertyPath)` Get the names of the columns mapped by a property path
`protected QueryableCollection` `AbstractEmptinessExpression.getQueryableCollection(String entityName, String propertyName, SessionFactoryImplementor factory)`
`Type` `CriteriaQuery.getType(Criteria criteria, String propertyPath)` Get the type of a property path, ignoring projection aliases
`TypedValue` `CriteriaQuery.getTypedValue(Criteria criteria, String propertyPath, Object value)` Get the a typed value for the given property value.
`TypedValue[]` `IdentifierEqExpression.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)`
`TypedValue[]` `BetweenExpression.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)`
`TypedValue[]` `LogicalExpression.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)`
`TypedValue[]` `SimpleSubqueryExpression.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)`
`TypedValue[]` `SubqueryExpression.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)`
`TypedValue[]` `PropertyExpression.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)`
`TypedValue[]` `LikeExpression.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)`
`TypedValue[]` `Criterion.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)` Return typed values for all parameters in the rendered SQL fragment
`TypedValue[]` `AbstractEmptinessExpression.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)`
`TypedValue[]` `NaturalIdentifier.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)`
`TypedValue[]` `SQLCriterion.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)`
`TypedValue[]` `Junction.getTypedValues(Criteria crit, CriteriaQuery criteriaQuery)`
`TypedValue[]` `NotExpression.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)`
`TypedValue[]` `Example.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)`
`TypedValue[]` `SimpleExpression.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)`
`TypedValue[]` `InExpression.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)`
`TypedValue[]` `NullExpression.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)`
`TypedValue[]` `IlikeExpression.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)` Deprecated.
`TypedValue[]` `NotNullExpression.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)`
`TypedValue[]` `SizeExpression.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)`
`Type[]` `AliasedProjection.getTypes(Criteria criteria, CriteriaQuery criteriaQuery)`
`Type[]` `PropertyProjection.getTypes(Criteria criteria, CriteriaQuery criteriaQuery)`
`Type[]` `SQLProjection.getTypes(Criteria crit, CriteriaQuery criteriaQuery)`
`Type[]` `Distinct.getTypes(Criteria criteria, CriteriaQuery criteriaQuery)`
`Type[]` `ProjectionList.getTypes(Criteria criteria, CriteriaQuery criteriaQuery)`
`Type[]` `AggregateProjection.getTypes(Criteria criteria, CriteriaQuery criteriaQuery)` Types returned by the rendered SQL `fragment`.
`Type[]` `RowCountProjection.getTypes(Criteria criteria, CriteriaQuery criteriaQuery)`
`Type[]` `Projection.getTypes(Criteria criteria, CriteriaQuery criteriaQuery)` Types returned by the rendered SQL `fragment`.
`Type[]` `IdentifierProjection.getTypes(Criteria criteria, CriteriaQuery criteriaQuery)`
`Type[]` `AliasedProjection.getTypes(String alias, Criteria criteria, CriteriaQuery criteriaQuery)`
`Type[]` `Distinct.getTypes(String alias, Criteria criteria, CriteriaQuery criteriaQuery)`
`Type[]` `Projection.getTypes(String alias, Criteria criteria, CriteriaQuery criteriaQuery)` Get the return types for a particular user-visible alias.
`Type` `CriteriaQuery.getTypeUsingProjection(Criteria criteria, String propertyPath)` Get the type of a property path
`DetachedCriteria` `DetachedCriteria.setFetchMode(String associationPath, FetchMode mode)`
`String` `PropertyProjection.toGroupSqlString(Criteria criteria, CriteriaQuery criteriaQuery)`
`String` `SQLProjection.toGroupSqlString(Criteria criteria, CriteriaQuery criteriaQuery)`
`String` `Distinct.toGroupSqlString(Criteria criteria, CriteriaQuery criteriaQuery)`
`String` `ProjectionList.toGroupSqlString(Criteria criteria, CriteriaQuery criteriaQuery)`
`String` `Projection.toGroupSqlString(Criteria criteria, CriteriaQuery criteriaQuery)` Render the SQL fragment to be used in the `GROUP BY` clause
`String` `IdentifierProjection.toGroupSqlString(Criteria criteria, CriteriaQuery criteriaQuery)`
`String` `IdentifierEqExpression.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)`
`String` `Order.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)` Render the SQL fragment
`String` `BetweenExpression.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)`
`String` `LogicalExpression.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)`
`String` `SubqueryExpression.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)`
`String` `PropertyExpression.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)`
`String` `LikeExpression.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)`
`String` `Criterion.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)` Render the SQL fragment
`String` `AbstractEmptinessExpression.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)`
`String` `NaturalIdentifier.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)`
`String` `SQLCriterion.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)`
`String` `Junction.toSqlString(Criteria crit, CriteriaQuery criteriaQuery)`
`String` `NotExpression.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)`
`String` `Example.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)`
`String` `SimpleExpression.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)`
`String` `InExpression.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)`
`String` `NullExpression.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)`
`String` `IlikeExpression.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)` Deprecated.
`String` `NotNullExpression.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)`
`String` `SizeExpression.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)`
`String` `AliasedProjection.toSqlString(Criteria criteria, int position, CriteriaQuery criteriaQuery)`
`String` `PropertyProjection.toSqlString(Criteria criteria, int position, CriteriaQuery criteriaQuery)`
`String` `SQLProjection.toSqlString(Criteria criteria, int loc, CriteriaQuery criteriaQuery)`
`String` `Distinct.toSqlString(Criteria criteria, int position, CriteriaQuery criteriaQuery)`
`String` `ProjectionList.toSqlString(Criteria criteria, int loc, CriteriaQuery criteriaQuery)`
`String` `AggregateProjection.toSqlString(Criteria criteria, int loc, CriteriaQuery criteriaQuery)` Render the SQL fragment to be used in the `SELECT` clause.
`String` `RowCountProjection.toSqlString(Criteria criteria, int position, CriteriaQuery criteriaQuery)`
`String` `Projection.toSqlString(Criteria criteria, int position, CriteriaQuery criteriaQuery)` Render the SQL fragment to be used in the `SELECT` clause.
`String` `IdentifierProjection.toSqlString(Criteria criteria, int position, CriteriaQuery criteriaQuery)`

Uses of HibernateException in org.hibernate.dialect

Methods in org.hibernate.dialect that throw HibernateException
`static Dialect` `Dialect.getDialect()` Get an instance of the dialect specified by the current `System` properties.
`static Dialect` `Dialect.getDialect(Properties props)` Get an instance of the dialect specified by the given properties or by the current `System` properties.
`String` `Dialect.getHibernateTypeName(int code)` Get the name of the Hibernate `Type` associated with the given `Types` type code.
`String` `Dialect.getHibernateTypeName(int code, int length, int precision, int scale)` Get the name of the Hibernate `Type` associated with the given `Types` typecode with the given storage specification parameters.
`String` `Dialect.getTypeName(int code)` Get the name of the database type associated with the given `Types` typecode.
`String` `TeradataDialect.getTypeName(int code, int length, int precision, int scale)` Get the name of the database type associated with the given `java.sql.Types` typecode.
`String` `Dialect.getTypeName(int code, long length, int precision, int scale)` Get the name of the database type associated with the given `Types` typecode with the given storage specification parameters.

Uses of HibernateException in org.hibernate.dialect.lock

Subclasses of HibernateException in org.hibernate.dialect.lock
`class` `LockingStrategyException` Represents an error trying to apply a `LockingStrategy` to an entity
`class` `OptimisticEntityLockException` Represents an error trying to apply an optimistic `LockingStrategy` to an entity
`class` `PessimisticEntityLockException` Represents an error trying to apply a pessimistic `LockingStrategy` to an entity

Uses of HibernateException in org.hibernate.ejb

Methods in org.hibernate.ejb with parameters of type HibernateException
`RuntimeException` `AbstractEntityManagerImpl.convert(HibernateException e)` Converts a Hibernate-specific exception into a JPA-specified exception; note that the JPA sepcification makes use of exceptions outside its exception hierarchy, though they are all runtime exceptions.
`RuntimeException` `HibernateEntityManagerImplementor.convert(HibernateException e)` Converts a Hibernate-specific exception into a JPA-specified exception; note that the JPA sepcification makes use of exceptions outside its exception hierarchy, though they are all runtime exceptions.
`RuntimeException` `AbstractEntityManagerImpl.convert(HibernateException e, LockOptions lockOptions)` Converts a Hibernate-specific exception into a JPA-specified exception; note that the JPA sepcification makes use of exceptions outside its exception hierarchy, though they are all runtime exceptions.
`RuntimeException` `HibernateEntityManagerImplementor.convert(HibernateException e, LockOptions lockOptions)` Converts a Hibernate-specific exception into a JPA-specified exception; note that the JPA sepcification makes use of exceptions outside its exception hierarchy, though they are all runtime exceptions.
`void` `AbstractEntityManagerImpl.throwPersistenceException(HibernateException e)` Delegates to `HibernateEntityManagerImplementor.convert(org.hibernate.HibernateException, org.hibernate.LockOptions)` and then throws the given exception.
`void` `HibernateEntityManagerImplementor.throwPersistenceException(HibernateException e)` Delegates to `HibernateEntityManagerImplementor.convert(org.hibernate.HibernateException, org.hibernate.LockOptions)` and then throws the given exception.
`PersistenceException` `AbstractEntityManagerImpl.wrapLockException(HibernateException e, LockOptions lockOptions)`

Methods in org.hibernate.ejb that throw HibernateException
`Ejb3Configuration` `Ejb3Configuration.configure(String resource)` Deprecated.

Uses of HibernateException in org.hibernate.ejb.connection

Methods in org.hibernate.ejb.connection that throw HibernateException
`void` `InjectedDataSourceConnectionProvider.configure(Properties props)`

Uses of HibernateException in org.hibernate.ejb.internal

Methods in org.hibernate.ejb.internal with parameters of type HibernateException
`void` `EntityManagerMessageLogger_$logger.namedQueryError(String arg0, HibernateException arg1)`
`void` `EntityManagerMessageLogger_$logger.unableToCloseSession(HibernateException arg0)`
`void` `EntityManagerMessageLogger_$logger.unableToCloseSessionButSwallowingError(HibernateException arg0)`
`void` `EntityManagerMessageLogger_$logger.unableToConfigureSqlExceptionConverter(HibernateException arg0)`
`void` `EntityManagerMessageLogger_$logger.unableToCreateProxyFactory(String arg0, HibernateException arg1)`
`void` `EntityManagerMessageLogger_$logger.unableToLoadCommand(HibernateException arg0)`
`void` `EntityManagerMessageLogger_$logger.unableToSynchronizeDatabaseStateWithSession(HibernateException arg0)`

Methods in org.hibernate.ejb.internal that throw HibernateException
`EntityManagerFactory` `EntityManagerFactoryRegistry.getNamedEntityManagerFactory(String name)` Lookup the specified entity manager factory by name
`void` `EntityManagerFactoryRegistry.removeEntityManagerFactory(String name, EntityManagerFactory entityManagerFactory)` remove the specified entity manager factory from the EntityManagerFactoryRegistry

Uses of HibernateException in org.hibernate.engine.internal

Methods in org.hibernate.engine.internal that throw HibernateException
`CollectionEntry` `StatefulPersistenceContext.addInitializedCollection(CollectionPersister persister, PersistentCollection collection, Serializable id)` add a collection we just pulled out of the cache (does not need initializing)
`void` `StatefulPersistenceContext.addInitializedDetachedCollection(CollectionPersister collectionPersister, PersistentCollection collection)` add an (initialized) collection that was created by another session and passed into update() (ie.
`void` `StatefulPersistenceContext.addNewCollection(CollectionPersister persister, PersistentCollection collection)` Add a new collection (ie.
`static int` `ParameterBinder.bindNamedParameters(PreparedStatement ps, Map namedParams, int start, ParameterBinder.NamedParameterSource source, SessionImplementor session)`
`static int` `ParameterBinder.bindNamedParameters(PreparedStatement ps, QueryParameters queryParameters, int start, ParameterBinder.NamedParameterSource source, SessionImplementor session)`
`static int` `ParameterBinder.bindPositionalParameters(PreparedStatement st, Object[] values, Type[] types, int start, SessionImplementor session)`
`static int` `ParameterBinder.bindPositionalParameters(PreparedStatement st, QueryParameters queryParameters, int start, SessionImplementor session)`
`static int` `ParameterBinder.bindQueryParameters(PreparedStatement st, QueryParameters queryParameters, int start, ParameterBinder.NamedParameterSource source, SessionImplementor session)`
`void` `Cascade.cascade(EntityPersister persister, Object parent)` Cascade an action from the parent entity instance to all its children.
`void` `Cascade.cascade(EntityPersister persister, Object parent, Object anything)` Cascade an action from the parent entity instance to all its children.
`void` `Nullability.checkNullability(Object[] values, EntityPersister persister, boolean isUpdate)` Check nullability of the class persister properties
`void` `StatefulPersistenceContext.checkUniqueness(EntityKey key, Object object)` Attempts to check whether the given key represents an entity already loaded within the current session.
`Object[]` `StatefulPersistenceContext.getDatabaseSnapshot(Serializable id, EntityPersister persister)` Get the current state of the entity as known to the underlying database, or null if there is no corresponding row
`static Serializable` `ForeignKeys.getEntityIdentifierIfNotUnsaved(String entityName, Object object, SessionImplementor session)` Return the identifier of the persistent or transient object, or throw an exception if the instance is "unsaved" Used by OneToOneType and ManyToOneType to determine what id value should be used for an object that may or may not be associated with the session.
`Object[]` `StatefulPersistenceContext.getNaturalIdSnapshot(Serializable id, EntityPersister persister)`
`static void` `TwoPhaseLoad.initializeEntity(Object entity, boolean readOnly, SessionImplementor session, PreLoadEvent preLoadEvent, PostLoadEvent postLoadEvent)` Perform the second step of 2-phase load.
`void` `StatefulPersistenceContext.initializeNonLazyCollections()` Force initialization of all non-lazy collections encountered during the current two-phase load (actually, this is a no-op, unless this is the "outermost" load)
`static boolean` `ForeignKeys.isNotTransient(String entityName, Object entity, Boolean assumed, SessionImplementor session)` Is this instance persistent or detached? If `assumed` is non-null, don't hit the database to make the determination, instead assume that value; the client code must be prepared to "recover" in the case that this assumed result is incorrect.
`static boolean` `ForeignKeys.isTransient(String entityName, Object entity, Boolean assumed, SessionImplementor session)` Is this instance, which we know is not persistent, actually transient? If `assumed` is non-null, don't hit the database to make the determination, instead assume that value; the client code must be prepared to "recover" in the case that this assumed result is incorrect.
`Object` `StatefulPersistenceContext.narrowProxy(Object proxy, EntityPersister persister, EntityKey key, Object object)` If the existing proxy is insufficiently "narrow" (derived), instantiate a new proxy and overwrite the registration of the old one.
`void` `ForeignKeys.Nullifier.nullifyTransientReferences(Object[] values, Type[] types)` Nullify all references to entities that have not yet been inserted in the database, where the foreign key points toward that entity
`static void` `TwoPhaseLoad.postHydrate(EntityPersister persister, Serializable id, Object[] values, Object rowId, Object object, LockMode lockMode, boolean lazyPropertiesAreUnfetched, SessionImplementor session)` Register the "hydrated" state of an entity instance, after the first step of 2-phase loading.
`Object` `StatefulPersistenceContext.proxyFor(EntityPersister persister, EntityKey key, Object impl)` Return the existing proxy associated with the given `EntityKey`, or the third argument (the entity associated with the key) if no proxy exists.
`Object` `StatefulPersistenceContext.proxyFor(Object impl)` Return the existing proxy associated with the given `EntityKey`, or the argument (the entity associated with the key) if no proxy exists.
`Object` `StatefulPersistenceContext.unproxy(Object maybeProxy)` Get the entity instance underlying the given proxy, throwing an exception if the proxy is uninitialized.
`Object` `StatefulPersistenceContext.unproxyAndReassociate(Object maybeProxy)` Possibly unproxy the given reference and reassociate it with the current session.

Uses of HibernateException in org.hibernate.engine.jdbc.internal

Methods in org.hibernate.engine.jdbc.internal that throw HibernateException
`Connection` `LogicalConnectionImpl.getConnection()`

Uses of HibernateException in org.hibernate.engine.jdbc.internal.proxy

Subclasses of HibernateException in org.hibernate.engine.jdbc.internal.proxy
`class` `JdbcProxyException` Indicates a problem defining or instantiating a JDBC proxy class.

Uses of HibernateException in org.hibernate.engine.query.spi

Methods in org.hibernate.engine.query.spi that throw HibernateException
`int` `NativeSQLQueryPlan.performExecuteUpdate(QueryParameters queryParameters, SessionImplementor session)`
`int` `HQLQueryPlan.performExecuteUpdate(QueryParameters queryParameters, SessionImplementor session)`
`Iterator` `HQLQueryPlan.performIterate(QueryParameters queryParameters, EventSource session)`
`List` `HQLQueryPlan.performList(QueryParameters queryParameters, SessionImplementor session)`
`ScrollableResults` `HQLQueryPlan.performScroll(QueryParameters queryParameters, SessionImplementor session)`

Uses of HibernateException in org.hibernate.engine.spi

Methods in org.hibernate.engine.spi that throw HibernateException
`CollectionEntry` `PersistenceContext.addInitializedCollection(CollectionPersister persister, PersistentCollection collection, Serializable id)` add a collection we just pulled out of the cache (does not need initializing)
`void` `PersistenceContext.addInitializedDetachedCollection(CollectionPersister collectionPersister, PersistentCollection collection)` add an (initialized) collection that was created by another session and passed into update() (ie.
`void` `PersistenceContext.addNewCollection(CollectionPersister persister, PersistentCollection collection)` Add a new collection (ie.
`void` `SessionImplementor.applyNonFlushedChanges(NonFlushedChanges nonFlushedChanges)` Apply non-flushed changes from a different session to this session.
`abstract void` `CascadingAction.cascade(EventSource session, Object child, String entityName, Object anything, boolean isCascadeDeleteEnabled)` Cascade the action to the child object.
`void` `PersistenceContext.checkUniqueness(EntityKey key, Object object)` Attempts to check whether the given key represents an entity already loaded within the current session.
`void` `ActionQueue.executeActions()` Perform all currently queued actions.
`void` `ActionQueue.executeInserts()` Perform all currently queued entity-insertion actions.
`int` `SessionImplementor.executeNativeUpdate(NativeSQLQuerySpecification specification, QueryParameters queryParameters)` Execute a native SQL update or delete query
`int` `SessionImplementor.executeUpdate(String query, QueryParameters queryParameters)` Execute a HQL update or delete query
`EntityPersister` `SessionImplementor.getEntityPersister(String entityName, Object object)` Get the `EntityPersister` for any instance
`Object` `SessionImplementor.getEntityUsingInterceptor(EntityKey key)` Get the entity instance associated with the given `Key`, calling the Interceptor if necessary
`NonFlushedChanges` `SessionImplementor.getNonFlushedChanges()` Return changes to this session that have not been flushed yet.
`Collection` `CollectionEntry.getOrphans(String entityName, PersistentCollection collection)` Get the collection orphans (entities which were removed from the collection)
`QueryCache` `SessionFactoryImplementor.getQueryCache(String regionName)` Get a particular named query cache, or the default cache
`String[]` `SessionFactoryImplementor.getReturnAliases(String queryString)` Get the return aliases of a query
`Type[]` `SessionFactoryImplementor.getReturnTypes(String queryString)` Get the return types of a query
`String` `SessionImplementor.guessEntityName(Object entity)` The guessed entity name for an entity not in an association
`Object` `SessionImplementor.immediateLoad(String entityName, Serializable id)` Load an instance immediately.
`void` `SessionImplementor.initializeCollection(PersistentCollection collection, boolean writing)` Initialize the collection (if not already initialized)
`void` `PersistenceContext.initializeNonLazyCollections()` Force initialization of all non-lazy collections encountered during the current two-phase load (actually, this is a no-op, unless this is the "outermost" load)
`Object` `SessionImplementor.instantiate(String entityName, Serializable id)` Instantiate the entity class, initializing with the given identifier
`Object` `SessionImplementor.internalLoad(String entityName, Serializable id, boolean eager, boolean nullable)` Load an instance without checking if it was deleted.
`Iterator` `SessionImplementor.iterate(String query, QueryParameters queryParameters)` Execute an `iterate()` query
`Iterator` `SessionImplementor.iterateFilter(Object collection, String filter, QueryParameters queryParameters)` Iterate a filter
`List` `SessionImplementor.list(NativeSQLQuerySpecification spec, QueryParameters queryParameters)` Execute a native SQL query, and return the results as a fully built list.
`List` `SessionImplementor.list(String query, QueryParameters queryParameters)` Execute a `find()` query
`List` `SessionImplementor.listCustomQuery(CustomQuery customQuery, QueryParameters queryParameters)` Execute an SQL Query
`List` `SessionImplementor.listFilter(Object collection, String filter, QueryParameters queryParameters)` Execute a filter
`Object` `PersistenceContext.narrowProxy(Object proxy, EntityPersister persister, EntityKey key, Object object)` If the existing proxy is insufficiently "narrow" (derived), instantiate a new proxy and overwrite the registration of the old one.
`Session` `SessionFactoryImplementor.openTemporarySession()` Get a nontransactional "current" session for Hibernate EntityManager
`void` `CollectionEntry.postFlush(PersistentCollection collection)` Called after a successful flush
`void` `CollectionEntry.postInitialize(PersistentCollection collection)`
`void` `CollectionEntry.preFlush(PersistentCollection collection)`
`void` `ActionQueue.prepareActions()` Prepares the internal action queues for execution.
`Object` `PersistenceContext.proxyFor(EntityPersister persister, EntityKey key, Object impl)` Return the existing proxy associated with the given `EntityKey`, or the third argument (the entity associated with the key) if no proxy exists.
`Object` `PersistenceContext.proxyFor(Object impl)` Return the existing proxy associated with the given `EntityKey`, or the argument (the entity associated with the key) if no proxy exists.
`ScrollableResults` `SessionImplementor.scroll(NativeSQLQuerySpecification spec, QueryParameters queryParameters)` Execute a native SQL query, and return the results as a scrollable result.
`ScrollableResults` `SessionImplementor.scroll(String query, QueryParameters queryParameters)` Execute a `scroll()` query
`ScrollableResults` `SessionImplementor.scrollCustomQuery(CustomQuery customQuery, QueryParameters queryParameters)` Execute an SQL Query
`void` `QueryParameters.traceParameters(SessionFactoryImplementor factory)`
`Object` `PersistenceContext.unproxy(Object maybeProxy)` Get the entity instance underlying the given proxy, throwing an exception if the proxy is uninitialized.
`Object` `PersistenceContext.unproxyAndReassociate(Object maybeProxy)` Possibly unproxy the given reference and reassociate it with the current session.

Uses of HibernateException in org.hibernate.engine.transaction.internal

Subclasses of HibernateException in org.hibernate.engine.transaction.internal
`class` `NullSynchronizationException` Indicates an attempt to register a null synchronization.

Uses of HibernateException in org.hibernate.engine.transaction.internal.jdbc

Methods in org.hibernate.engine.transaction.internal.jdbc that throw HibernateException

`

`<T> T`

`

`JdbcIsolationDelegate.delegateWork(WorkExecutorVisitable<T> work, boolean transacted)`

`boolean` `JdbcTransaction.isActive()`

Uses of HibernateException in org.hibernate.engine.transaction.internal.jta

Methods in org.hibernate.engine.transaction.internal.jta that throw HibernateException

`

`<T> T`

`

`JtaIsolationDelegate.delegateWork(WorkExecutorVisitable<T> work, boolean transacted)`

`boolean` `JtaTransaction.isActive()`

Uses of HibernateException in org.hibernate.engine.transaction.spi

Methods in org.hibernate.engine.transaction.spi that throw HibernateException
`void` `AbstractTransactionImpl.begin()`
`void` `AbstractTransactionImpl.commit()`

`

`<T> T`

`

`IsolationDelegate.delegateWork(WorkExecutorVisitable<T> work, boolean transacted)`
Perform the given work in isolation from current transaction.

`void` `AbstractTransactionImpl.rollback()`
`boolean` `AbstractTransactionImpl.wasRolledBack()`

Uses of HibernateException in org.hibernate.envers

Methods in org.hibernate.envers that throw HibernateException
`String` `AuditReader.getEntityName(Object primaryKey, Number revision, Object entity)`

Uses of HibernateException in org.hibernate.envers.entities

Methods in org.hibernate.envers.entities that throw HibernateException
`Object` `RevisionTypeType.assemble(Serializable cached, Object owner)`
`Object` `RevisionTypeType.deepCopy(Object value)`
`Serializable` `RevisionTypeType.disassemble(Object value)`
`boolean` `RevisionTypeType.equals(Object x, Object y)`
`int` `RevisionTypeType.hashCode(Object x)`
`RevisionType` `RevisionTypeType.nullSafeGet(ResultSet resultSet, String[] names, SessionImplementor session, Object owner)`
`void` `RevisionTypeType.nullSafeSet(PreparedStatement preparedStatement, Object value, int index, SessionImplementor session)`
`Object` `RevisionTypeType.replace(Object original, Object target, Object owner)`

Uses of HibernateException in org.hibernate.envers.entities.mapper.relation.lazy

Methods in org.hibernate.envers.entities.mapper.relation.lazy that throw HibernateException
`void` `AbstractDelegateSessionImplementor.applyNonFlushedChanges(NonFlushedChanges nonFlushedChanges)`
`Object` `ToOneDelegateSessionImplementor.doImmediateLoad(String entityName)`
`int` `AbstractDelegateSessionImplementor.executeNativeUpdate(NativeSQLQuerySpecification specification, QueryParameters queryParameters)`
`int` `AbstractDelegateSessionImplementor.executeUpdate(String query, QueryParameters queryParameters)`
`EntityPersister` `AbstractDelegateSessionImplementor.getEntityPersister(String entityName, Object object)`
`Object` `AbstractDelegateSessionImplementor.getEntityUsingInterceptor(EntityKey key)`
`NonFlushedChanges` `AbstractDelegateSessionImplementor.getNonFlushedChanges()`
`String` `AbstractDelegateSessionImplementor.guessEntityName(Object entity)`
`Object` `AbstractDelegateSessionImplementor.immediateLoad(String entityName, Serializable id)`
`void` `AbstractDelegateSessionImplementor.initializeCollection(PersistentCollection collection, boolean writing)`
`Object` `AbstractDelegateSessionImplementor.instantiate(String entityName, Serializable id)`
`Object` `AbstractDelegateSessionImplementor.internalLoad(String entityName, Serializable id, boolean eager, boolean nullable)`
`Iterator` `AbstractDelegateSessionImplementor.iterate(String query, QueryParameters queryParameters)`
`Iterator` `AbstractDelegateSessionImplementor.iterateFilter(Object collection, String filter, QueryParameters queryParameters)`
`List` `AbstractDelegateSessionImplementor.list(NativeSQLQuerySpecification spec, QueryParameters queryParameters)`
`List` `AbstractDelegateSessionImplementor.list(String query, QueryParameters queryParameters)`
`List` `AbstractDelegateSessionImplementor.listCustomQuery(CustomQuery customQuery, QueryParameters queryParameters)`
`List` `AbstractDelegateSessionImplementor.listFilter(Object collection, String filter, QueryParameters queryParameters)`
`ScrollableResults` `AbstractDelegateSessionImplementor.scroll(NativeSQLQuerySpecification spec, QueryParameters queryParameters)`
`ScrollableResults` `AbstractDelegateSessionImplementor.scroll(String query, QueryParameters queryParameters)`
`ScrollableResults` `AbstractDelegateSessionImplementor.scrollCustomQuery(CustomQuery customQuery, QueryParameters queryParameters)`

Uses of HibernateException in org.hibernate.envers.exception

Subclasses of HibernateException in org.hibernate.envers.exception
`class` `AuditException`
`class` `NotAuditedException`
`class` `RevisionDoesNotExistException`

Uses of HibernateException in org.hibernate.envers.internal

Methods in org.hibernate.envers.internal with parameters of type HibernateException
`void` `EnversMessageLogger_$logger.namedQueryError(String arg0, HibernateException arg1)`
`void` `EnversMessageLogger_$logger.unableToCloseSession(HibernateException arg0)`
`void` `EnversMessageLogger_$logger.unableToCloseSessionButSwallowingError(HibernateException arg0)`
`void` `EnversMessageLogger_$logger.unableToConfigureSqlExceptionConverter(HibernateException arg0)`
`void` `EnversMessageLogger_$logger.unableToCreateProxyFactory(String arg0, HibernateException arg1)`
`void` `EnversMessageLogger_$logger.unableToLoadCommand(HibernateException arg0)`
`void` `EnversMessageLogger_$logger.unableToSynchronizeDatabaseStateWithSession(HibernateException arg0)`

Uses of HibernateException in org.hibernate.envers.reader

Methods in org.hibernate.envers.reader that throw HibernateException
`String` `AuditReaderImpl.getEntityName(Object primaryKey, Number revision, Object entity)`

Uses of HibernateException in org.hibernate.event.internal

Methods in org.hibernate.event.internal that throw HibernateException
`protected void` `DefaultDeleteEventListener.cascadeAfterDelete(EventSource session, EntityPersister persister, Object entity, Set transientEntities)`
`protected void` `DefaultMergeEventListener.cascadeAfterSave(EventSource source, EntityPersister persister, Object entity, Object anything)` Cascade behavior is redefined by this subclass, disable superclass behavior
`protected void` `DefaultDeleteEventListener.cascadeBeforeDelete(EventSource session, EntityPersister persister, Object entity, EntityEntry entityEntry, Set transientEntities)`
`protected void` `DefaultMergeEventListener.cascadeBeforeSave(EventSource source, EntityPersister persister, Object entity, Object anything)` Cascade behavior is redefined by this subclass, disable superclass behavior
`void` `DefaultFlushEntityEventListener.checkId(Object object, EntityPersister persister, Serializable id, SessionImplementor session)` make sure user didn't mangle the id
`protected void` `DefaultFlushEntityEventListener.dirtyCheck(FlushEntityEvent event)` Perform a dirty check, and attach the results to the event
`protected void` `DefaultEvictEventListener.doEvict(Object object, EntityKey key, EntityPersister persister, EventSource session)`
`protected Serializable` `DefaultSaveOrUpdateEventListener.entityIsPersistent(SaveOrUpdateEvent event)`
`protected void` `AbstractFlushingEventListener.flushEverythingToExecutions(FlushEvent event)` Coordinates the processing necessary to get things ready for executions as db calls by preping the session caches and moving the appropriate entities and collections to their respective execution queues.
`protected Serializable` `DefaultUpdateEventListener.getUpdateId(Object entity, EntityPersister persister, Serializable requestedId, SessionImplementor session)` If the user specified an id, assign it to the instance and use that, otherwise use the id already assigned to the instance
`protected boolean` `DefaultFlushEntityEventListener.isUpdateNecessary(FlushEntityEvent event)` Performs all necessary checking to determine if an entity needs an SQL update to synchronize its state to the database.
`protected Object` `DefaultLoadEventListener.loadFromSessionCache(LoadEvent event, EntityKey keyToLoad, LoadEventListener.LoadType options)` Attempts to locate the entity in the session-level cache.
`void` `DefaultAutoFlushEventListener.onAutoFlush(AutoFlushEvent event)` Handle the given auto-flush event.
`void` `DefaultDeleteEventListener.onDelete(DeleteEvent event)` Handle the given delete event.
`void` `DefaultDeleteEventListener.onDelete(DeleteEvent event, Set transientEntities)` Handle the given delete event.
`void` `DefaultDirtyCheckEventListener.onDirtyCheck(DirtyCheckEvent event)` Handle the given dirty-check event.
`void` `DefaultEvictEventListener.onEvict(EvictEvent event)` Handle the given evict event.
`void` `DefaultFlushEventListener.onFlush(FlushEvent event)` Handle the given flush event.
`void` `DefaultFlushEntityEventListener.onFlushEntity(FlushEntityEvent event)` Flushes a single entity's state to the database, by scheduling an update action, if necessary
`void` `DefaultInitializeCollectionEventListener.onInitializeCollection(InitializeCollectionEvent event)` called by a collection that wants to initialize itself
`void` `DefaultLoadEventListener.onLoad(LoadEvent event, LoadEventListener.LoadType loadType)` Handle the given load event.
`void` `DefaultLockEventListener.onLock(LockEvent event)` Handle the given lock event.
`void` `DefaultMergeEventListener.onMerge(MergeEvent event)` Handle the given merge event.
`void` `DefaultMergeEventListener.onMerge(MergeEvent event, Map copiedAlready)` Handle the given merge event.
`void` `DefaultPersistEventListener.onPersist(PersistEvent event)` Handle the given create event.
`void` `DefaultPersistEventListener.onPersist(PersistEvent event, Map createCache)` Handle the given create event.
`void` `DefaultRefreshEventListener.onRefresh(RefreshEvent event)`
`void` `DefaultResolveNaturalIdEventListener.onResolveNaturalId(ResolveNaturalIdEvent event)`
`protected void` `DefaultSaveOrUpdateEventListener.performUpdate(SaveOrUpdateEvent event, Object entity, EntityPersister persister)`
`protected void` `AbstractFlushingEventListener.postFlush(SessionImplementor session)` 1.
`void` `AbstractVisitor.processEntityPropertyValues(Object[] values, Type[] types)` Dispatch each property value to processValue().
`protected void` `ProxyVisitor.reattachCollection(PersistentCollection collection, CollectionType type)` Reattach a detached (disassociated) initialized or uninitialized collection wrapper, using a snapshot carried with the collection wrapper

Uses of HibernateException in org.hibernate.event.service.spi

Subclasses of HibernateException in org.hibernate.event.service.spi
`class` `EventListenerRegistrationException` Indicates a problem registering an event listener.

Uses of HibernateException in org.hibernate.event.spi

Methods in org.hibernate.event.spi that throw HibernateException
`void` `EventSource.forceFlush(EntityEntry e)` Force an immediate flush
`Object` `EventSource.instantiate(EntityPersister persister, Serializable id)` Instantiate an entity instance, using either an interceptor, or the given persister
`void` `EventSource.merge(String entityName, Object object, Map copiedAlready)` Cascade merge an entity instance
`void` `AutoFlushEventListener.onAutoFlush(AutoFlushEvent event)` Handle the given auto-flush event.
`void` `DeleteEventListener.onDelete(DeleteEvent event)` Handle the given delete event.
`void` `DeleteEventListener.onDelete(DeleteEvent event, Set transientEntities)`
`void` `DirtyCheckEventListener.onDirtyCheck(DirtyCheckEvent event)` Handle the given dirty-check event.
`void` `EvictEventListener.onEvict(EvictEvent event)` Handle the given evict event.
`void` `FlushEventListener.onFlush(FlushEvent event)` Handle the given flush event.
`void` `FlushEntityEventListener.onFlushEntity(FlushEntityEvent event)`
`void` `InitializeCollectionEventListener.onInitializeCollection(InitializeCollectionEvent event)`
`void` `LoadEventListener.onLoad(LoadEvent event, LoadEventListener.LoadType loadType)` Handle the given load event.
`void` `LockEventListener.onLock(LockEvent event)` Handle the given lock event.
`void` `MergeEventListener.onMerge(MergeEvent event)` Handle the given merge event.
`void` `MergeEventListener.onMerge(MergeEvent event, Map copiedAlready)` Handle the given merge event.
`void` `PersistEventListener.onPersist(PersistEvent event)` Handle the given create event.
`void` `PersistEventListener.onPersist(PersistEvent event, Map createdAlready)` Handle the given create event.
`void` `RefreshEventListener.onRefresh(RefreshEvent event)` Handle the given refresh event.
`void` `RefreshEventListener.onRefresh(RefreshEvent event, Map refreshedAlready)`
`void` `ReplicateEventListener.onReplicate(ReplicateEvent event)` Handle the given replicate event.
`void` `ResolveNaturalIdEventListener.onResolveNaturalId(ResolveNaturalIdEvent event)` Handle the given resolve natural id event.
`void` `SaveOrUpdateEventListener.onSaveOrUpdate(SaveOrUpdateEvent event)` Handle the given update event.
`void` `EventSource.persist(String entityName, Object object, Map createdAlready)` Cascade persist an entity instance
`void` `EventSource.refresh(Object object, Map refreshedAlready)` Cascade refresh an entity instance

Uses of HibernateException in org.hibernate.exception

Subclasses of HibernateException in org.hibernate.exception
`class` `ConstraintViolationException` Implementation of JDBCException indicating that the requested DML operation resulted in a violation of a defined integrity constraint.
`class` `DataException` Implementation of JDBCException indicating that evaluation of the valid SQL statement against the given data resulted in some illegal operation, mismatched types or incorrect cardinality.
`class` `GenericJDBCException` Generic, non-specific JDBCException.
`class` `JDBCConnectionException` Implementation of JDBCException indicating problems with communicating with the database (can also include incorrect JDBC setup).
`class` `LockAcquisitionException` Implementation of JDBCException indicating a problem acquiring lock on the database.
`class` `SQLGrammarException` Implementation of JDBCException indicating that the SQL sent to the database server was invalid (syntax error, invalid object references, etc).

Uses of HibernateException in org.hibernate.exception.spi

Methods in org.hibernate.exception.spi that throw HibernateException
`static SQLExceptionConverter` `SQLExceptionConverterFactory.buildSQLExceptionConverter(Dialect dialect, Properties properties)` Build a SQLExceptionConverter instance.
`void` `Configurable.configure(Properties properties)` Configure the component, using the given settings and properties.

Uses of HibernateException in org.hibernate.hql.internal

Subclasses of HibernateException in org.hibernate.hql.internal
`class` `QueryExecutionRequestException` Expecting to execute an illegal operation regarding the query type

Uses of HibernateException in org.hibernate.hql.internal.ast

Subclasses of HibernateException in org.hibernate.hql.internal.ast
`class` `InvalidWithClauseException` Indicates an issue with the encountered with-clause.
`class` `QuerySyntaxException` Exception thrown when there is a syntax error in the HQL.

Methods in org.hibernate.hql.internal.ast that throw HibernateException
`int` `QueryTranslatorImpl.executeUpdate(QueryParameters queryParameters, SessionImplementor session)`
`Iterator` `QueryTranslatorImpl.iterate(QueryParameters queryParameters, EventSource session)` Return the query results as an iterator
`List` `QueryTranslatorImpl.list(SessionImplementor session, QueryParameters queryParameters)`
`ScrollableResults` `QueryTranslatorImpl.scroll(QueryParameters queryParameters, SessionImplementor session)` Return the query results, as an instance of `ScrollableResults`
`void` `QueryTranslatorImpl.validateScrollability()`

Uses of HibernateException in org.hibernate.hql.internal.ast.exec

Methods in org.hibernate.hql.internal.ast.exec that throw HibernateException
`int` `MultiTableDeleteExecutor.execute(QueryParameters parameters, SessionImplementor session)`
`int` `MultiTableUpdateExecutor.execute(QueryParameters parameters, SessionImplementor session)`
`int` `StatementExecutor.execute(QueryParameters parameters, SessionImplementor session)` Execute the sql managed by this executor using the given parameters.
`int` `BasicExecutor.execute(QueryParameters parameters, SessionImplementor session)`

Uses of HibernateException in org.hibernate.hql.internal.classic

Methods in org.hibernate.hql.internal.classic that throw HibernateException
`int` `QueryTranslatorImpl.executeUpdate(QueryParameters queryParameters, SessionImplementor session)`
`protected Object` `QueryTranslatorImpl.getResultColumnOrRow(Object[] row, ResultTransformer transformer, ResultSet rs, SessionImplementor session)`
`protected Object[]` `QueryTranslatorImpl.getResultRow(Object[] row, ResultSet rs, SessionImplementor session)`
`Iterator` `QueryTranslatorImpl.iterate(QueryParameters queryParameters, EventSource session)` Return the query results as an iterator
`List` `QueryTranslatorImpl.list(SessionImplementor session, QueryParameters queryParameters)`
`ScrollableResults` `QueryTranslatorImpl.scroll(QueryParameters queryParameters, SessionImplementor session)`
`void` `QueryTranslatorImpl.validateScrollability()`

Uses of HibernateException in org.hibernate.hql.spi

Methods in org.hibernate.hql.spi that throw HibernateException
`int` `QueryTranslator.executeUpdate(QueryParameters queryParameters, SessionImplementor session)` Perform a bulk update/delete operation given the underlying query definition.
`Iterator` `QueryTranslator.iterate(QueryParameters queryParameters, EventSource session)` Perform an iterate operation given the underlying query definition.
`List` `QueryTranslator.list(SessionImplementor session, QueryParameters queryParameters)` Perform a list operation given the underlying query definition.
`ScrollableResults` `QueryTranslator.scroll(QueryParameters queryParameters, SessionImplementor session)` Perform a scroll operation given the underlying query definition.
`void` `QueryTranslator.validateScrollability()` Validate the scrollability of the translated query.

Uses of HibernateException in org.hibernate.id

Subclasses of HibernateException in org.hibernate.id
`class` `IdentifierGenerationException` Thrown by `IdentifierGenerator` implementation class when ID generation fails.

Methods in org.hibernate.id that throw HibernateException
`Serializable` `GUIDGenerator.generate(SessionImplementor session, Object obj)`
`Serializable` `Assigned.generate(SessionImplementor session, Object obj)`
`Serializable` `IncrementGenerator.generate(SessionImplementor session, Object object)`
`Serializable` `IdentifierGenerator.generate(SessionImplementor session, Object object)` Generate a new identifier.
`Serializable` `UUIDGenerator.generate(SessionImplementor session, Object object)`
`Serializable` `CompositeNestedGeneratedValueGenerator.generate(SessionImplementor session, Object object)`
`static Serializable` `IdentifierGeneratorHelper.getGeneratedIdentity(ResultSet rs, String identifier, Type type)` Get the generated identifier when using identity columns
`InsertGeneratedIdentifierDelegate` `PostInsertIdentifierGenerator.getInsertGeneratedIdentifierDelegate(PostInsertIdentityPersister persister, Dialect dialect, boolean isGetGeneratedKeysEnabled)`
`InsertGeneratedIdentifierDelegate` `SelectGenerator.getInsertGeneratedIdentifierDelegate(PostInsertIdentityPersister persister, Dialect dialect, boolean isGetGeneratedKeysEnabled)`
`InsertGeneratedIdentifierDelegate` `IdentityGenerator.getInsertGeneratedIdentifierDelegate(PostInsertIdentityPersister persister, Dialect dialect, boolean isGetGeneratedKeysEnabled)`
`InsertGeneratedIdentifierDelegate` `SequenceIdentityGenerator.getInsertGeneratedIdentifierDelegate(PostInsertIdentityPersister persister, Dialect dialect, boolean isGetGeneratedKeysEnabled)`
`String[]` `TableGenerator.sqlCreateStrings(Dialect dialect)`
`String[]` `SequenceGenerator.sqlCreateStrings(Dialect dialect)`
`String[]` `MultipleHiLoPerTableGenerator.sqlCreateStrings(Dialect dialect)`
`String[]` `PersistentIdentifierGenerator.sqlCreateStrings(Dialect dialect)` The SQL required to create the underlying database objects.
`String[]` `SequenceGenerator.sqlDropStrings(Dialect dialect)`
`String[]` `MultipleHiLoPerTableGenerator.sqlDropStrings(Dialect dialect)`
`String[]` `PersistentIdentifierGenerator.sqlDropStrings(Dialect dialect)` The SQL required to remove the underlying database objects.

Uses of HibernateException in org.hibernate.id.enhanced

Methods in org.hibernate.id.enhanced that throw HibernateException
`Serializable` `SequenceStyleGenerator.generate(SessionImplementor session, Object object)`
`String[]` `SequenceStyleGenerator.sqlCreateStrings(Dialect dialect)`
`String[]` `TableGenerator.sqlCreateStrings(Dialect dialect)`
`String[]` `SequenceStructure.sqlCreateStrings(Dialect dialect)`
`String[]` `TableStructure.sqlCreateStrings(Dialect dialect)`
`String[]` `SequenceStyleGenerator.sqlDropStrings(Dialect dialect)`
`String[]` `TableGenerator.sqlDropStrings(Dialect dialect)`
`String[]` `SequenceStructure.sqlDropStrings(Dialect dialect)`
`String[]` `TableStructure.sqlDropStrings(Dialect dialect)`

Uses of HibernateException in org.hibernate.internal

Methods in org.hibernate.internal with parameters of type HibernateException
`void` `CoreMessageLogger.namedQueryError(String queryName, HibernateException e)`
`void` `CoreMessageLogger_$logger.namedQueryError(String queryName, HibernateException e)`
`void` `CoreMessageLogger.unableToCloseSession(HibernateException e)`
`void` `CoreMessageLogger_$logger.unableToCloseSession(HibernateException e)`
`void` `CoreMessageLogger.unableToCloseSessionButSwallowingError(HibernateException e)`
`void` `CoreMessageLogger_$logger.unableToCloseSessionButSwallowingError(HibernateException e)`
`void` `CoreMessageLogger.unableToConfigureSqlExceptionConverter(HibernateException e)`
`void` `CoreMessageLogger_$logger.unableToConfigureSqlExceptionConverter(HibernateException e)`
`void` `CoreMessageLogger.unableToCreateProxyFactory(String entityName, HibernateException e)`
`void` `CoreMessageLogger_$logger.unableToCreateProxyFactory(String entityName, HibernateException e)`
`void` `CoreMessageLogger.unableToLoadCommand(HibernateException e)`
`void` `CoreMessageLogger_$logger.unableToLoadCommand(HibernateException e)`
`void` `CoreMessageLogger.unableToSynchronizeDatabaseStateWithSession(HibernateException he)`
`void` `CoreMessageLogger_$logger.unableToSynchronizeDatabaseStateWithSession(HibernateException he)`

Methods in org.hibernate.internal that throw HibernateException
`void` `FetchingScrollableResultsImpl.afterLast()` Go to a location just after the last result
`void` `ScrollableResultsImpl.afterLast()`
`void` `SessionImpl.applyNonFlushedChanges(NonFlushedChanges nonFlushedChanges)` Apply non-flushed changes from a different session to this session.
`protected boolean` `SessionImpl.autoFlushIfRequired(Set querySpaces)` detect in-memory changes, determine if the changes are to tables named in the query and, if so, complete execution the flush
`void` `FetchingScrollableResultsImpl.beforeFirst()` Go to a location just before first result (this is the initial location)
`void` `ScrollableResultsImpl.beforeFirst()`
`Transaction` `SessionImpl.beginTransaction()`
`Transaction` `StatelessSessionImpl.beginTransaction()`
`void` `SessionImpl.cancelQuery()`
`void` `SessionFactoryImpl.close()` Closes the session factory, releasing all held resources.
`void` `AbstractScrollableResults.close()`
`Connection` `SessionImpl.close()`
`Connection` `SessionImpl.connection()`
`Criteria` `CriteriaImpl.createAlias(String associationPath, String alias, int joinType)`
`Criteria` `CriteriaImpl.Subcriteria.createAlias(String associationPath, String alias, int joinType)`
`Criteria` `CriteriaImpl.createAlias(String associationPath, String alias, int joinType, Criterion withClause)`
`Criteria` `CriteriaImpl.Subcriteria.createAlias(String associationPath, String alias, int joinType, Criterion withClause)`
`Criteria` `CriteriaImpl.Subcriteria.createAlias(String associationPath, String alias, JoinType joinType)`
`Criteria` `CriteriaImpl.Subcriteria.createAlias(String associationPath, String alias, JoinType joinType, Criterion withClause)`
`Criteria` `CriteriaImpl.createCriteria(String associationPath, int joinType)`
`Criteria` `CriteriaImpl.Subcriteria.createCriteria(String associationPath, int joinType)`
`Criteria` `CriteriaImpl.Subcriteria.createCriteria(String associationPath, JoinType joinType)`
`Criteria` `CriteriaImpl.createCriteria(String associationPath, String alias, int joinType)`
`Criteria` `CriteriaImpl.Subcriteria.createCriteria(String associationPath, String alias, int joinType)`
`Criteria` `CriteriaImpl.createCriteria(String associationPath, String alias, int joinType, Criterion withClause)`
`Criteria` `CriteriaImpl.Subcriteria.createCriteria(String associationPath, String alias, int joinType, Criterion withClause)`
`Criteria` `CriteriaImpl.Subcriteria.createCriteria(String associationPath, String alias, JoinType joinType)`
`Criteria` `CriteriaImpl.Subcriteria.createCriteria(String associationPath, String alias, JoinType joinType, Criterion withClause)`
`void` `SessionImpl.delete(Object object)` Delete a persistent object
`void` `SessionImpl.delete(String entityName, Object object)` Delete a persistent object (by explicit entity name)
`void` `SessionImpl.delete(String entityName, Object object, boolean isCascadeDeleteEnabled, Set transientEntities)` Delete a persistent object
`protected Type` `AbstractQueryImpl.determineType(int paramPosition, Object paramValue)`
`protected Type` `AbstractQueryImpl.determineType(String paramName, Class clazz)`
`protected Type` `AbstractQueryImpl.determineType(String paramName, Object paramValue)`
`Connection` `SessionImpl.disconnect()`

`

`<T> T`

`

`SessionImpl.doReturningWork(ReturningWork<T> work)`

`void` `SessionImpl.doWork(Work work)`
`void` `SessionFactoryImpl.evict(Class persistentClass)`
`void` `SessionFactoryImpl.evict(Class persistentClass, Serializable id)`
`void` `SessionImpl.evict(Object object)` remove any hard references to the entity that are held by the infrastructure (references held by application or other persistant instances are okay)
`void` `SessionFactoryImpl.evictCollection(String roleName)`
`void` `SessionFactoryImpl.evictCollection(String roleName, Serializable id)`
`void` `SessionFactoryImpl.evictEntity(String entityName)`
`void` `SessionFactoryImpl.evictEntity(String entityName, Serializable id)`
`void` `SessionFactoryImpl.evictQueries()`
`void` `SessionFactoryImpl.evictQueries(String regionName)`
`int` `SessionImpl.executeNativeUpdate(NativeSQLQuerySpecification nativeQuerySpecification, QueryParameters queryParameters)`
`int` `StatelessSessionImpl.executeNativeUpdate(NativeSQLQuerySpecification nativeSQLQuerySpecification, QueryParameters queryParameters)`
`int` `QueryImpl.executeUpdate()`
`int` `SQLQueryImpl.executeUpdate()`
`int` `SessionImpl.executeUpdate(String query, QueryParameters queryParameters)`
`int` `StatelessSessionImpl.executeUpdate(String query, QueryParameters queryParameters)`
`boolean` `FetchingScrollableResultsImpl.first()` Go to the first result
`boolean` `ScrollableResultsImpl.first()`
`void` `SessionImpl.flush()`
`void` `SessionImpl.forceFlush(EntityEntry entityEntry)`
`Object[]` `AbstractScrollableResults.get()`
`Object` `SessionImpl.get(Class entityClass, Serializable id)`
`Object` `SessionImpl.get(Class entityClass, Serializable id, LockMode lockMode)`
`Object` `SessionImpl.get(Class entityClass, Serializable id, LockOptions lockOptions)`
`Object` `AbstractScrollableResults.get(int col)`
`Object` `SessionImpl.get(String entityName, Serializable id)`
`Object` `SessionImpl.get(String entityName, Serializable id, LockMode lockMode)`
`Object` `SessionImpl.get(String entityName, Serializable id, LockOptions lockOptions)`
`Map<String,ClassMetadata>` `SessionFactoryImpl.getAllClassMetadata()`
`Map` `SessionFactoryImpl.getAllCollectionMetadata()`
`BigDecimal` `AbstractScrollableResults.getBigDecimal(int col)`
`BigInteger` `AbstractScrollableResults.getBigInteger(int col)`
`byte[]` `AbstractScrollableResults.getBinary(int col)`
`Blob` `AbstractScrollableResults.getBlob(int col)`
`Boolean` `AbstractScrollableResults.getBoolean(int col)`
`Byte` `AbstractScrollableResults.getByte(int col)`
`Calendar` `AbstractScrollableResults.getCalendar(int col)`
`Character` `AbstractScrollableResults.getCharacter(int col)`
`ClassMetadata` `SessionFactoryImpl.getClassMetadata(Class persistentClass)`
`ClassMetadata` `SessionFactoryImpl.getClassMetadata(String entityName)`
`Clob` `AbstractScrollableResults.getClob(int col)`
`CollectionMetadata` `SessionFactoryImpl.getCollectionMetadata(String roleName)`
`LockMode` `SessionImpl.getCurrentLockMode(Object object)`
`Session` `SessionFactoryImpl.getCurrentSession()`
`Date` `AbstractScrollableResults.getDate(int col)`
`Double` `AbstractScrollableResults.getDouble(int col)`
`EntityPersister` `StatelessSessionImpl.getEntityPersister(String entityName, Object object)`
`Object` `SessionImpl.getEntityUsingInterceptor(EntityKey key)`
`Object` `StatelessSessionImpl.getEntityUsingInterceptor(EntityKey key)`
`FilterDefinition` `SessionFactoryImpl.getFilterDefinition(String filterName)`
`protected Object` `AbstractScrollableResults.getFinal(int col, Type returnType)` Check that the requested type is compatible with the result type, and return the column value.
`Float` `AbstractScrollableResults.getFloat(int col)`
`protected HQLQueryPlan` `AbstractSessionImpl.getHQLQueryPlan(String query, boolean shallow)`
`Serializable` `SessionImpl.getIdentifier(Object object)`
`Integer` `AbstractScrollableResults.getInteger(int col)`
`Locale` `AbstractScrollableResults.getLocale(int col)`
`Long` `AbstractScrollableResults.getLong(int col)`
`String[]` `AbstractQueryImpl.getNamedParameters()` Returns an array representing all named parameter names encountered during (intial) parsing of the query.
`protected NativeSQLQueryPlan` `AbstractSessionImpl.getNativeSQLQueryPlan(NativeSQLQuerySpecification spec)`
`protected Object` `AbstractScrollableResults.getNonFinal(int col, Type returnType)` Check that the requested type is compatible with the result type, and return the column value.
`NonFlushedChanges` `SessionImpl.getNonFlushedChanges()` Return changes to this session and its child sessions that have not been flushed yet.
`QueryCache` `SessionFactoryImpl.getQueryCache(String regionName)`
`String[]` `SQLQueryImpl.getReturnAliases()`
`String[]` `AbstractQueryImpl.getReturnAliases()`
`String[]` `SessionFactoryImpl.getReturnAliases(String queryString)`
`Type[]` `SQLQueryImpl.getReturnTypes()`
`Type[]` `AbstractQueryImpl.getReturnTypes()`
`Type[]` `SessionFactoryImpl.getReturnTypes(String queryString)`
`int` `FetchingScrollableResultsImpl.getRowNumber()` Get the current location in the result set.
`int` `ScrollableResultsImpl.getRowNumber()`
`Short` `AbstractScrollableResults.getShort(int col)`
`String` `AbstractScrollableResults.getString(int col)`
`String` `AbstractScrollableResults.getText(int col)`
`TimeZone` `AbstractScrollableResults.getTimeZone(int col)`
`Transaction` `SessionImpl.getTransaction()`
`Transaction` `StatelessSessionImpl.getTransaction()`
`String` `SessionImpl.guessEntityName(Object object)`
`String` `StatelessSessionImpl.guessEntityName(Object entity)`
`Object` `SessionImpl.immediateLoad(String entityName, Serializable id)` Load the data for the object with the specified id into a newly created object.
`Object` `StatelessSessionImpl.immediateLoad(String entityName, Serializable id)`
`void` `SessionImpl.initializeCollection(PersistentCollection collection, boolean writing)`
`void` `StatelessSessionImpl.initializeCollection(PersistentCollection collection, boolean writing)`
`Object` `SessionImpl.instantiate(EntityPersister persister, Serializable id)` give the interceptor an opportunity to override the default instantiation
`Object` `SessionImpl.instantiate(String entityName, Serializable id)`
`Object` `StatelessSessionImpl.instantiate(String entityName, Serializable id)`
`Object` `SessionImpl.internalLoad(String entityName, Serializable id, boolean eager, boolean nullable)`
`Object` `StatelessSessionImpl.internalLoad(String entityName, Serializable id, boolean eager, boolean nullable)`
`boolean` `SessionImpl.isDirty()`
`boolean` `FetchingScrollableResultsImpl.isFirst()` Is this the first result?
`boolean` `ScrollableResultsImpl.isFirst()`
`boolean` `FetchingScrollableResultsImpl.isLast()` Is this the last result?
`boolean` `ScrollableResultsImpl.isLast()`
`Iterator` `QueryImpl.iterate()`
`Iterator` `SQLQueryImpl.iterate()`
`Iterator` `CollectionFilterImpl.iterate()`
`Iterator` `SessionImpl.iterate(String query, QueryParameters queryParameters)`
`Iterator` `StatelessSessionImpl.iterate(String query, QueryParameters queryParameters)`
`Iterator` `SessionImpl.iterateFilter(Object collection, String filter, QueryParameters queryParameters)`
`Iterator` `StatelessSessionImpl.iterateFilter(Object collection, String filter, QueryParameters queryParameters)`
`boolean` `FetchingScrollableResultsImpl.last()` Go to the last result
`boolean` `ScrollableResultsImpl.last()`
`List` `CriteriaImpl.list()`
`List` `CriteriaImpl.Subcriteria.list()`
`List` `QueryImpl.list()`
`List` `SQLQueryImpl.list()`
`List` `CollectionFilterImpl.list()`
`List` `SessionImpl.list(CriteriaImpl criteria)`
`List` `StatelessSessionImpl.list(CriteriaImpl criteria)`
`List` `AbstractSessionImpl.list(NativeSQLQuerySpecification spec, QueryParameters queryParameters)`
`List` `SessionImpl.list(String query, QueryParameters queryParameters)`
`List` `StatelessSessionImpl.list(String query, QueryParameters queryParameters)`
`List` `SessionImpl.listCustomQuery(CustomQuery customQuery, QueryParameters queryParameters)`
`List` `StatelessSessionImpl.listCustomQuery(CustomQuery customQuery, QueryParameters queryParameters)`
`List` `SessionImpl.listFilter(Object collection, String filter, QueryParameters queryParameters)`
`List` `StatelessSessionImpl.listFilter(Object collection, String filter, QueryParameters queryParameters)`
`Object` `SessionImpl.load(Class entityClass, Serializable id)`
`Object` `SessionImpl.load(Class entityClass, Serializable id, LockMode lockMode)`
`Object` `SessionImpl.load(Class entityClass, Serializable id, LockOptions lockOptions)`
`void` `SessionImpl.load(Object object, Serializable id)`
`Object` `SessionImpl.load(String entityName, Serializable id)`
`Object` `SessionImpl.load(String entityName, Serializable id, LockMode lockMode)`
`Object` `SessionImpl.load(String entityName, Serializable id, LockOptions lockOptions)`
`void` `SessionImpl.lock(Object object, LockMode lockMode)`
`void` `SessionImpl.lock(String entityName, Object object, LockMode lockMode)`
`Object` `SessionImpl.merge(Object object)`
`Object` `SessionImpl.merge(String entityName, Object object)`
`void` `SessionImpl.merge(String entityName, Object object, Map copiedAlready)`
`boolean` `FetchingScrollableResultsImpl.next()` Advance to the next result
`Object` `IteratorImpl.next()`
`boolean` `ScrollableResultsImpl.next()`
`Session` `SessionFactoryImpl.openSession()`
`Session` `SessionFactoryImpl.openTemporarySession()`
`void` `SessionImpl.persist(Object object)`
`void` `SessionImpl.persist(String entityName, Object object)`
`void` `SessionImpl.persist(String entityName, Object object, Map copiedAlready)`
`void` `SessionImpl.persistOnFlush(Object object)`
`void` `SessionImpl.persistOnFlush(String entityName, Object object)`
`void` `SessionImpl.persistOnFlush(String entityName, Object object, Map copiedAlready)`
`boolean` `FetchingScrollableResultsImpl.previous()` Retreat to the previous result
`boolean` `ScrollableResultsImpl.previous()`
`void` `SessionImpl.reconnect(Connection conn)`
`void` `SessionImpl.refresh(Object object)`
`void` `SessionImpl.refresh(Object object, LockMode lockMode)`
`void` `SessionImpl.refresh(Object object, LockOptions lockOptions)`
`void` `SessionImpl.refresh(Object object, Map refreshedAlready)`
`void` `SessionImpl.refresh(String entityName, Object object)`
`void` `SessionImpl.refresh(String entityName, Object object, LockOptions lockOptions)`
`void` `SessionImpl.replicate(Object obj, ReplicationMode replicationMode)`
`void` `SessionImpl.replicate(String entityName, Object obj, ReplicationMode replicationMode)`
`Serializable` `SessionImpl.save(Object obj)`
`Serializable` `SessionImpl.save(String entityName, Object object)`
`void` `SessionImpl.saveOrUpdate(Object object)`
`void` `SessionImpl.saveOrUpdate(String entityName, Object obj)`
`ScrollableResults` `CriteriaImpl.Subcriteria.scroll()`
`ScrollableResults` `QueryImpl.scroll()`
`ScrollableResults` `SQLQueryImpl.scroll()`
`ScrollableResults` `CollectionFilterImpl.scroll()`
`boolean` `FetchingScrollableResultsImpl.scroll(int positions)` Scroll an arbitrary number of locations
`boolean` `ScrollableResultsImpl.scroll(int i)`
`ScrollableResults` `AbstractSessionImpl.scroll(NativeSQLQuerySpecification spec, QueryParameters queryParameters)`
`ScrollableResults` `CriteriaImpl.Subcriteria.scroll(ScrollMode scrollMode)`
`ScrollableResults` `QueryImpl.scroll(ScrollMode scrollMode)`
`ScrollableResults` `SQLQueryImpl.scroll(ScrollMode scrollMode)`
`ScrollableResults` `SessionImpl.scroll(String query, QueryParameters queryParameters)`
`ScrollableResults` `StatelessSessionImpl.scroll(String query, QueryParameters queryParameters)`
`ScrollableResults` `SessionImpl.scrollCustomQuery(CustomQuery customQuery, QueryParameters queryParameters)`
`ScrollableResults` `StatelessSessionImpl.scrollCustomQuery(CustomQuery customQuery, QueryParameters queryParameters)`
`void` `StatelessSessionImpl.setDefaultReadOnly(boolean readOnly)`
`Query` `AbstractQueryImpl.setParameter(int position, Object val)`
`Query` `AbstractQueryImpl.setParameter(String name, Object val)`
`Filter` `FilterImpl.setParameterList(String name, Collection values)` Set the named parameter's value list for this filter.
`Query` `AbstractQueryImpl.setParameterList(String name, Collection vals)`
`Query` `AbstractQueryImpl.setParameterList(String name, Collection vals, Type type)`
`Query` `AbstractQueryImpl.setParameterList(String name, Object[] vals)`
`Query` `AbstractQueryImpl.setParameterList(String name, Object[] vals, Type type)`
`Query` `AbstractQueryImpl.setProperties(Map map)`
`Query` `AbstractQueryImpl.setProperties(Object bean)`
`boolean` `FetchingScrollableResultsImpl.setRowNumber(int rowNumber)` Set the current location in the result set, numbered from either the first row (row number `0`), or the last row (row number `-1`).
`boolean` `ScrollableResultsImpl.setRowNumber(int rowNumber)`
`Object` `CriteriaImpl.uniqueResult()`
`Object` `CriteriaImpl.Subcriteria.uniqueResult()`
`Object` `AbstractQueryImpl.uniqueResult()`
`void` `SessionImpl.update(Object obj)`
`void` `SessionImpl.update(String entityName, Object object)`
`void` `FilterImpl.validate()` Perform validation of the filter state.
`protected void` `AbstractQueryImpl.verifyParameters(boolean reserveFirstParameter)` Perform parameter validation.

Constructors in org.hibernate.internal that throw HibernateException
`IteratorImpl(ResultSet rs, PreparedStatement ps, EventSource sess, boolean readOnly, Type[] types, String[][] columnNames, HolderInstantiator holderInstantiator)`
`SessionFactoryImpl(Configuration cfg, Mapping mapping, ServiceRegistry serviceRegistry, Settings settings, SessionFactoryObserver observer)`
`SessionFactoryImpl(MetadataImplementor metadata, SessionFactory.SessionFactoryOptions sessionFactoryOptions, SessionFactoryObserver observer)`

Uses of HibernateException in org.hibernate.internal.util

Methods in org.hibernate.internal.util that throw HibernateException
`static Properties` `ConfigHelper.getConfigProperties(String path)` Loads a properties instance based on the data at the incoming config location.
`static InputStream` `ConfigHelper.getConfigStream(String path)` Open an InputStream to the URL represented by the incoming path.
`static Reader` `ConfigHelper.getConfigStreamReader(String path)` Open an Reader to the URL represented by the incoming path.
`void` `EntityPrinter.toString(Iterable<Map.Entry<EntityKey,Object>> entitiesByEntityKey)`
`String` `EntityPrinter.toString(Map<String,TypedValue> namedTypedValues)`
`String` `EntityPrinter.toString(String entityName, Object entity)` Renders an entity to a string.
`String` `EntityPrinter.toString(Type[] types, Object[] values)`
`void` `Cloneable.validate()` Checks to ensure the SessionEventListenerConfig is fully configured (basically, that none of the listeners is null).

Uses of HibernateException in org.hibernate.internal.util.beans

Subclasses of HibernateException in org.hibernate.internal.util.beans
`class` `BeanIntrospectionException` Indicates a problem dealing with `BeanInfo` via the `BeanInfoHelper` delegate.

Uses of HibernateException in org.hibernate.internal.util.config

Subclasses of HibernateException in org.hibernate.internal.util.config
`class` `ConfigurationException` TODO : javadoc

Uses of HibernateException in org.hibernate.jdbc

Subclasses of HibernateException in org.hibernate.jdbc
`class` `BatchedTooManyRowsAffectedException` Much like `TooManyRowsAffectedException`, indicates that more rows than what we were expcecting were affected.
`class` `BatchFailedException` Indicates a failed batch entry (-3 return).
`class` `TooManyRowsAffectedException` Indicates that more rows were affected then we were expecting to be.

Methods in org.hibernate.jdbc that throw HibernateException
`int` `Expectations.BasicExpectation.prepare(PreparedStatement statement)`
`int` `Expectations.BasicParamExpectation.prepare(PreparedStatement statement)`
`int` `Expectation.prepare(PreparedStatement statement)` Perform any special statement preparation.
`void` `Expectation.verifyOutcome(int rowCount, PreparedStatement statement, int batchPosition)` Perform verification of the outcome of the RDBMS operation based on the type of expectation defined.

Uses of HibernateException in org.hibernate.jmx

Methods in org.hibernate.jmx that throw HibernateException
`void` `SessionFactoryStub.close()` Deprecated.
`void` `HibernateServiceMBean.createSchema()` Deprecated. Export the `CREATE` DDL to the database
`void` `HibernateServiceMBean.dropSchema()` Deprecated. Export the `DROP` DDL to the database
`void` `SessionFactoryStub.evict(Class persistentClass)` Deprecated.
`void` `SessionFactoryStub.evict(Class persistentClass, Serializable id)` Deprecated.
`void` `SessionFactoryStub.evictCollection(String roleName)` Deprecated.
`void` `SessionFactoryStub.evictCollection(String roleName, Serializable id)` Deprecated.
`void` `SessionFactoryStub.evictEntity(String entityName)` Deprecated.
`void` `SessionFactoryStub.evictEntity(String entityName, Serializable id)` Deprecated.
`void` `SessionFactoryStub.evictQueries()` Deprecated.
`void` `SessionFactoryStub.evictQueries(String cacheRegion)` Deprecated.
`Map<String,ClassMetadata>` `SessionFactoryStub.getAllClassMetadata()` Deprecated.
`Map` `SessionFactoryStub.getAllCollectionMetadata()` Deprecated.
`ClassMetadata` `SessionFactoryStub.getClassMetadata(Class persistentClass)` Deprecated.
`ClassMetadata` `SessionFactoryStub.getClassMetadata(String entityName)` Deprecated.
`CollectionMetadata` `SessionFactoryStub.getCollectionMetadata(String roleName)` Deprecated.
`FilterDefinition` `SessionFactoryStub.getFilterDefinition(String filterName)` Deprecated.
`Session` `SessionFactoryStub.openSession()` Deprecated.
`void` `HibernateService.start()` Deprecated.
`void` `HibernateServiceMBean.start()` Deprecated. Create the `SessionFactory` and bind to the jndi name on startup

Uses of HibernateException in org.hibernate.loader

Subclasses of HibernateException in org.hibernate.loader
`class` `MultipleBagFetchException` Exception used to indicate that a query is attempting to simultaneously fetch multiple `bags`

Methods in org.hibernate.loader that throw HibernateException
`protected String` `Loader.applyLocks(String sql, LockOptions lockOptions, Dialect dialect)` Append `FOR UPDATE OF` clause, if necessary.
`protected int` `Loader.bindNamedParameters(PreparedStatement statement, Map namedParams, int startIndex, SessionImplementor session)` Bind named parameters to the JDBC prepared statement.
`protected int` `Loader.bindPositionalParameters(PreparedStatement statement, QueryParameters queryParameters, int startIndex, SessionImplementor session)` Bind positional parameter values to the JDBC prepared statement.
`protected void` `Loader.checkScrollability()` Check whether the current loader can support returning ScrollableResults.
`protected List` `Loader.doList(SessionImplementor session, QueryParameters queryParameters)` Actually execute a query, ignoring the query cache
`protected Object` `Loader.getResultColumnOrRow(Object[] row, ResultTransformer transformer, ResultSet rs, SessionImplementor session)` Get the actual object that is returned in the user-visible result list.
`protected Object[]` `Loader.getResultRow(Object[] row, ResultSet rs, SessionImplementor session)`
`protected ResultSet` `Loader.getResultSet(PreparedStatement st, boolean autodiscovertypes, boolean callable, RowSelection selection, SessionImplementor session)` Fetch a `PreparedStatement`, call `setMaxRows` and then execute it, advance to the first result and return an SQL `ResultSet`
`protected List` `Loader.list(SessionImplementor session, QueryParameters queryParameters, Set querySpaces, Type[] resultTypes)` Return the query results, using the query cache, called by subclasses that implement cacheable queries
`void` `Loader.loadCollection(SessionImplementor session, Serializable id, Type type)` Called by subclasses that initialize collections
`void` `Loader.loadCollectionBatch(SessionImplementor session, Serializable[] ids, Type type)` Called by wrappers that batch initialize collections
`protected void` `Loader.loadCollectionSubselect(SessionImplementor session, Serializable[] ids, Object[] parameterValues, Type[] parameterTypes, Map namedParameters, Type type)` Called by subclasses that batch initialize collections
`protected List` `Loader.loadEntity(SessionImplementor session, Object key, Object index, Type keyType, Type indexType, EntityPersister persister)` Called by subclasses that load entities
`protected List` `Loader.loadEntity(SessionImplementor session, Object id, Type identifierType, Object optionalObject, String optionalEntityName, Serializable optionalIdentifier, EntityPersister persister, LockOptions lockOptions)` Called by subclasses that load entities
`List` `Loader.loadEntityBatch(SessionImplementor session, Serializable[] ids, Type idType, Object optionalObject, String optionalEntityName, Serializable optionalId, EntityPersister persister, LockOptions lockOptions)` Called by wrappers that batch load entities
`Object` `Loader.loadSequentialRowsForward(ResultSet resultSet, SessionImplementor session, QueryParameters queryParameters, boolean returnProxies)` Loads a single logical row from the result set moving forward.
`Object` `Loader.loadSequentialRowsReverse(ResultSet resultSet, SessionImplementor session, QueryParameters queryParameters, boolean returnProxies, boolean isLogicallyAfterLast)` Loads a single logical row from the result set moving forward.
`Object` `Loader.loadSingleRow(ResultSet resultSet, SessionImplementor session, QueryParameters queryParameters, boolean returnProxies)` Loads a single row from the result set.
`protected PreparedStatement` `Loader.prepareQueryStatement(QueryParameters queryParameters, boolean scroll, SessionImplementor session)` Obtain a `PreparedStatement` with all parameters pre-bound.
`protected String` `Loader.preprocessSQL(String sql, QueryParameters parameters, Dialect dialect)` Modify the SQL, adding lock hints and comments, if necessary
`protected ScrollableResults` `Loader.scroll(QueryParameters queryParameters, Type[] returnTypes, HolderInstantiator holderInstantiator, SessionImplementor session)` Return the query results, as an instance of `ScrollableResults`

Uses of HibernateException in org.hibernate.loader.collection

Methods in org.hibernate.loader.collection that throw HibernateException
`void` `CollectionInitializer.initialize(Serializable id, SessionImplementor session)` Initialize the given collection
`void` `SubselectCollectionLoader.initialize(Serializable id, SessionImplementor session)`
`void` `CollectionLoader.initialize(Serializable id, SessionImplementor session)`
`void` `BatchingCollectionInitializer.initialize(Serializable id, SessionImplementor session)`
`void` `SubselectOneToManyLoader.initialize(Serializable id, SessionImplementor session)`

Uses of HibernateException in org.hibernate.loader.criteria

Methods in org.hibernate.loader.criteria that throw HibernateException
`String[]` `CriteriaQueryTranslator.findColumns(String propertyName, Criteria subcriteria)` Get the names of the columns mapped by a property path; if the property path is not found in subcriteria, try the "outer" query.
`String[]` `CriteriaQueryTranslator.getColumns(String propertyName, Criteria subcriteria)`
`String[]` `CriteriaQueryTranslator.getColumnsUsingProjection(Criteria subcriteria, String propertyName)` Get the names of the columns constrained by this criterion.
`protected Object` `CriteriaLoader.getResultColumnOrRow(Object[] row, ResultTransformer transformer, ResultSet rs, SessionImplementor session)`
`protected Object[]` `CriteriaLoader.getResultRow(Object[] row, ResultSet rs, SessionImplementor session)`
`Type` `CriteriaQueryTranslator.getType(Criteria subcriteria, String propertyName)`
`TypedValue` `CriteriaQueryTranslator.getTypedValue(Criteria subcriteria, String propertyName, Object value)` Get the a typed value for the given property value.
`Type` `CriteriaQueryTranslator.getTypeUsingProjection(Criteria subcriteria, String propertyName)`
`List` `CriteriaLoader.list(SessionImplementor session)`
`ScrollableResults` `CriteriaLoader.scroll(SessionImplementor session, ScrollMode scrollMode)`

Constructors in org.hibernate.loader.criteria that throw HibernateException
`CriteriaLoader(OuterJoinLoadable persister, SessionFactoryImplementor factory, CriteriaImpl criteria, String rootEntityName, LoadQueryInfluencers loadQueryInfluencers)`
`CriteriaQueryTranslator(SessionFactoryImplementor factory, CriteriaImpl criteria, String rootEntityName, String rootSQLAlias)`
`CriteriaQueryTranslator(SessionFactoryImplementor factory, CriteriaImpl criteria, String rootEntityName, String rootSQLAlias, CriteriaQuery outerQuery)`

Uses of HibernateException in org.hibernate.loader.custom

Subclasses of HibernateException in org.hibernate.loader.custom
`class` `NonUniqueDiscoveredSqlAliasException`

Methods in org.hibernate.loader.custom that throw HibernateException
`Object` `CustomLoader.ResultRowProcessor.buildResultRow(Object[] data, ResultSet resultSet, boolean hasTransformer, SessionImplementor session)` Build a logical result row.
`Object[]` `CustomLoader.ResultRowProcessor.buildResultRow(Object[] data, ResultSet resultSet, SessionImplementor session)`
`Object` `CustomLoader.NonScalarResultColumnProcessor.extract(Object[] data, ResultSet resultSet, SessionImplementor session)`
`Object` `CustomLoader.ScalarResultColumnProcessor.extract(Object[] data, ResultSet resultSet, SessionImplementor session)`
`protected Object` `CustomLoader.getResultColumnOrRow(Object[] row, ResultTransformer transformer, ResultSet rs, SessionImplementor session)`
`protected Object[]` `CustomLoader.getResultRow(Object[] row, ResultSet rs, SessionImplementor session)`
`List` `CustomLoader.list(SessionImplementor session, QueryParameters queryParameters)`
`ScrollableResults` `CustomLoader.scroll(QueryParameters queryParameters, SessionImplementor session)`

Uses of HibernateException in org.hibernate.loader.custom.sql

Constructors in org.hibernate.loader.custom.sql that throw HibernateException
`SQLCustomQuery(String sqlQuery, NativeSQLQueryReturn[] queryReturns, Collection additionalQuerySpaces, SessionFactoryImplementor factory)`

Uses of HibernateException in org.hibernate.loader.entity

Methods in org.hibernate.loader.entity that throw HibernateException
`protected Object` `CollectionElementLoader.getResultColumnOrRow(Object[] row, ResultTransformer transformer, ResultSet rs, SessionImplementor session)`
`protected Object` `AbstractEntityLoader.getResultColumnOrRow(Object[] row, ResultTransformer transformer, ResultSet rs, SessionImplementor session)`
`Object` `UniqueEntityLoader.load(Serializable id, Object optionalObject, SessionImplementor session)` Deprecated. use `UniqueEntityLoader.load(java.io.Serializable, Object, SessionImplementor, LockOptions)` instead.
`Object` `CollectionElementLoader.loadElement(SessionImplementor session, Object key, Object index)`

Uses of HibernateException in org.hibernate.loader.hql

Methods in org.hibernate.loader.hql that throw HibernateException
`protected Object` `QueryLoader.getResultColumnOrRow(Object[] row, ResultTransformer transformer, ResultSet rs, SessionImplementor session)`
`protected Object[]` `QueryLoader.getResultRow(Object[] row, ResultSet rs, SessionImplementor session)`
`Iterator` `QueryLoader.iterate(QueryParameters queryParameters, EventSource session)`
`List` `QueryLoader.list(SessionImplementor session, QueryParameters queryParameters)`
`ScrollableResults` `QueryLoader.scroll(QueryParameters queryParameters, SessionImplementor session)`
`void` `QueryLoader.validateScrollability()`

Uses of HibernateException in org.hibernate.mapping

Methods in org.hibernate.mapping that throw HibernateException
`String` `Column.getSqlType(Dialect dialect, Mapping mapping)`
`Iterator` `Table.sqlAlterStrings(Dialect dialect, Mapping p, TableMetadata tableInfo, String defaultCatalog, String defaultSchema)`
`String` `SimpleAuxiliaryDatabaseObject.sqlCreateString(Dialect dialect, Mapping p, String defaultCatalog, String defaultSchema)`
`String` `RelationalModel.sqlCreateString(Dialect dialect, Mapping p, String defaultCatalog, String defaultSchema)`
`String` `Index.sqlCreateString(Dialect dialect, Mapping mapping, String defaultCatalog, String defaultSchema)`
`String` `Table.sqlTemporaryTableCreateString(Dialect dialect, Mapping mapping)`

Uses of HibernateException in org.hibernate.metadata

Methods in org.hibernate.metadata that throw HibernateException
`Serializable` `ClassMetadata.getIdentifier(Object object)` Deprecated. Use `ClassMetadata.getIdentifier(Object,SessionImplementor)` instead
`Type` `ClassMetadata.getPropertyType(String propertyName)` Get the type of a particular (named) property
`Object` `ClassMetadata.getPropertyValue(Object object, String propertyName)` Get the value of a particular (named) property
`Object[]` `ClassMetadata.getPropertyValues(Object entity)` Extract the property values from the given entity.
`Object[]` `ClassMetadata.getPropertyValuesToInsert(Object entity, Map mergeMap, SessionImplementor session)` Return the values of the mapped properties of the object
`Object` `ClassMetadata.getVersion(Object object)` Get the version number (or timestamp) from the object's version property (or return null if not versioned)
`void` `ClassMetadata.setPropertyValue(Object object, String propertyName, Object value)` Set the value of a particular (named) property
`void` `ClassMetadata.setPropertyValues(Object object, Object[] values)` Set the given values to the mapped properties of the given object

Uses of HibernateException in org.hibernate.metamodel

Subclasses of HibernateException in org.hibernate.metamodel
`class` `ValidationException` Indicates a problem validating the metamodel.

Uses of HibernateException in org.hibernate.metamodel.relational

Subclasses of HibernateException in org.hibernate.metamodel.relational
`class` `IllegalIdentifierException` Indicates an attempted use of a name that was deemed illegal

Uses of HibernateException in org.hibernate.metamodel.source

Subclasses of HibernateException in org.hibernate.metamodel.source
`class` `XsdException` Indicates an issue finding or loading an XSD schema.

Uses of HibernateException in org.hibernate.metamodel.source.annotations

Subclasses of HibernateException in org.hibernate.metamodel.source.annotations
`class` `UnknownInheritanceTypeException`

Uses of HibernateException in org.hibernate.persister.collection

Methods in org.hibernate.persister.collection that throw HibernateException
`void` `CollectionPersister.deleteRows(PersistentCollection collection, Serializable key, SessionImplementor session)` Delete the persistent state of any elements that were removed from the collection
`void` `AbstractCollectionPersister.deleteRows(PersistentCollection collection, Serializable id, SessionImplementor session)`
`protected int` `BasicCollectionPersister.doUpdateRows(Serializable id, PersistentCollection collection, SessionImplementor session)`
`protected abstract int` `AbstractCollectionPersister.doUpdateRows(Serializable key, PersistentCollection collection, SessionImplementor session)`
`void` `CollectionPersister.initialize(Serializable key, SessionImplementor session)` Initialize the given collection with the given key
`void` `AbstractCollectionPersister.initialize(Serializable key, SessionImplementor session)`
`void` `NamedQueryCollectionInitializer.initialize(Serializable key, SessionImplementor session)`
`void` `CollectionPersister.insertRows(PersistentCollection collection, Serializable key, SessionImplementor session)` Insert the persistent state of any new collection elements
`void` `AbstractCollectionPersister.insertRows(PersistentCollection collection, Serializable id, SessionImplementor session)`
`Object` `CollectionPersister.readElement(ResultSet rs, Object owner, String[] columnAliases, SessionImplementor session)` Read the element from a row of the JDBC `ResultSet`
`Object` `AbstractCollectionPersister.readElement(ResultSet rs, Object owner, String[] aliases, SessionImplementor session)`
`Object` `CollectionPersister.readIdentifier(ResultSet rs, String columnAlias, SessionImplementor session)` Read the identifier from a row of the JDBC `ResultSet`
`Object` `AbstractCollectionPersister.readIdentifier(ResultSet rs, String alias, SessionImplementor session)`
`Object` `CollectionPersister.readIndex(ResultSet rs, String[] columnAliases, SessionImplementor session)` Read the index from a row of the JDBC `ResultSet`
`Object` `AbstractCollectionPersister.readIndex(ResultSet rs, String[] aliases, SessionImplementor session)`
`Object` `CollectionPersister.readKey(ResultSet rs, String[] keyAliases, SessionImplementor session)` Read the key from a row of the JDBC `ResultSet`
`Object` `AbstractCollectionPersister.readKey(ResultSet rs, String[] aliases, SessionImplementor session)`
`void` `CollectionPersister.recreate(PersistentCollection collection, Serializable key, SessionImplementor session)` (Re)create the collection's persistent state
`void` `AbstractCollectionPersister.recreate(PersistentCollection collection, Serializable id, SessionImplementor session)`
`void` `CollectionPersister.remove(Serializable id, SessionImplementor session)` Completely remove the persistent state of the collection
`void` `AbstractCollectionPersister.remove(Serializable id, SessionImplementor session)`
`void` `CollectionPersister.updateRows(PersistentCollection collection, Serializable key, SessionImplementor session)` Update the persistent state of any elements that were modified
`void` `AbstractCollectionPersister.updateRows(PersistentCollection collection, Serializable id, SessionImplementor session)`
`protected int` `AbstractCollectionPersister.writeElement(PreparedStatement st, Object elt, int i, SessionImplementor session)` Write the element to a JDBC `PreparedStatement`
`protected int` `AbstractCollectionPersister.writeElementToWhere(PreparedStatement st, Object elt, int i, SessionImplementor session)` Write the element to a JDBC `PreparedStatement`
`int` `AbstractCollectionPersister.writeIdentifier(PreparedStatement st, Object id, int i, SessionImplementor session)` Write the identifier to a JDBC `PreparedStatement`
`protected int` `AbstractCollectionPersister.writeIndex(PreparedStatement st, Object index, int i, SessionImplementor session)` Write the index to a JDBC `PreparedStatement`
`protected int` `AbstractCollectionPersister.writeIndexToWhere(PreparedStatement st, Object index, int i, SessionImplementor session)` Write the index to a JDBC `PreparedStatement`
`protected int` `AbstractCollectionPersister.writeKey(PreparedStatement st, Serializable key, int i, SessionImplementor session)` Write the key to a JDBC `PreparedStatement`

Uses of HibernateException in org.hibernate.persister.entity

Methods in org.hibernate.persister.entity that throw HibernateException
`protected boolean` `AbstractEntityPersister.check(int rows, Serializable id, int tableNumber, Expectation expectation, PreparedStatement statement)`
`Object` `AbstractEntityPersister.createProxy(Serializable id, SessionImplementor session)`
`Object` `EntityPersister.createProxy(Serializable id, SessionImplementor session)` Create a new proxy instance
`Object` `DiscriminatorType.deepCopy(Object value, SessionFactoryImplementor factory)`
`protected int` `AbstractEntityPersister.dehydrate(Serializable id, Object[] fields, boolean[] includeProperty, boolean[][] includeColumns, int j, PreparedStatement st, SessionImplementor session)`
`protected int` `AbstractEntityPersister.dehydrate(Serializable id, Object[] fields, Object rowId, boolean[] includeProperty, boolean[][] includeColumns, int j, PreparedStatement ps, SessionImplementor session, int index)` Marshall the fields of a persistent instance to a prepared statement
`protected void` `AbstractEntityPersister.delete(Serializable id, Object version, int j, Object object, String sql, SessionImplementor session, Object[] loadedState)` Perform an SQL DELETE
`void` `AbstractEntityPersister.delete(Serializable id, Object version, Object object, SessionImplementor session)` Delete an object
`void` `EntityPersister.delete(Serializable id, Object version, Object object, SessionImplementor session)` Delete a persistent instance
`int[]` `AbstractEntityPersister.findDirty(Object[] currentState, Object[] previousState, Object entity, SessionImplementor session)` Locate the property-indices of all properties considered to be dirty.
`int[]` `AbstractEntityPersister.findModified(Object[] old, Object[] current, Object entity, SessionImplementor session)` Locate the property-indices of all properties considered to be dirty.
`Object` `EntityPersister.forceVersionIncrement(Serializable id, Object currentVersion, SessionImplementor session)`
`Object` `DiscriminatorType.fromXMLNode(org.dom4j.Node xml, Mapping factory)`
`Object` `AbstractEntityPersister.getCurrentVersion(Serializable id, SessionImplementor session)` Retrieve the version number
`Object` `EntityPersister.getCurrentVersion(Serializable id, SessionImplementor session)` Get the current version of the object, or return null if there is no row for the given identifier.
`Object[]` `AbstractEntityPersister.getDatabaseSnapshot(Serializable id, SessionImplementor session)`
`Object[]` `EntityPersister.getDatabaseSnapshot(Serializable id, SessionImplementor session)` Get the current database state of the object, in a "hydrated" form, without resolving identifiers
`Serializable` `EntityPersister.getIdentifier(Object object)` Deprecated. Use `EntityPersister.getIdentifier(Object,SessionImplementor)` instead
`IdentifierGenerator` `AbstractEntityPersister.getIdentifierGenerator()`
`Object[]` `AbstractEntityPersister.getNaturalIdentifierSnapshot(Serializable id, SessionImplementor session)`
`Object` `EntityPersister.getPropertyValue(Object object, int i)` Get the value of a particular property
`Object[]` `AbstractEntityPersister.getPropertyValuesToInsert(Object object, Map mergeMap, SessionImplementor session)`
`Object[]` `EntityPersister.getPropertyValuesToInsert(Object object, Map mergeMap, SessionImplementor session)` Return the values of the insertable properties of the object (including backrefs)
`Object` `EntityPersister.getVersion(Object object)` Get the version number (or timestamp) from the object's version property (or return null if not versioned)
`Object[]` `Loadable.hydrate(ResultSet rs, Serializable id, Object object, Loadable rootLoadable, String[][] suffixedPropertyColumns, boolean allProperties, SessionImplementor session)` Retrieve property values from one row of a result set
`Object[]` `AbstractEntityPersister.hydrate(ResultSet rs, Serializable id, Object object, Loadable rootLoadable, String[][] suffixedPropertyColumns, boolean allProperties, SessionImplementor session)` Unmarshall the fields of a persistent instance from a result set, without resolving associations or collections.
`Object` `AbstractEntityPersister.initializeLazyProperty(String fieldName, Object entity, SessionImplementor session)`
`protected Serializable` `AbstractEntityPersister.insert(Object[] fields, boolean[] notNull, String sql, Object object, SessionImplementor session)` Perform an SQL INSERT, and then retrieve a generated identifier.
`Serializable` `AbstractEntityPersister.insert(Object[] fields, Object object, SessionImplementor session)`
`Serializable` `EntityPersister.insert(Object[] fields, Object object, SessionImplementor session)` Persist an instance, using a natively generated identifier (optional operation)
`protected void` `AbstractEntityPersister.insert(Serializable id, Object[] fields, boolean[] notNull, int j, String sql, Object object, SessionImplementor session)` Perform an SQL INSERT.
`void` `AbstractEntityPersister.insert(Serializable id, Object[] fields, Object object, SessionImplementor session)`
`void` `EntityPersister.insert(Serializable id, Object[] fields, Object object, SessionImplementor session)` Persist an instance
`boolean` `DiscriminatorType.isDirty(Object old, Object current, boolean[] checkable, SessionImplementor session)`
`Boolean` `AbstractEntityPersister.isTransient(Object entity, SessionImplementor session)`
`Boolean` `EntityPersister.isTransient(Object object, SessionImplementor session)` Is this a new transient instance?
`Object` `EntityPersister.load(Serializable id, Object optionalObject, LockMode lockMode, SessionImplementor session)` Load an instance of the persistent class.
`Object` `AbstractEntityPersister.load(Serializable id, Object optionalObject, LockOptions lockOptions, SessionImplementor session)` Load an instance using either the `forUpdateLoader` or the outer joining `loader`, depending upon the value of the `lock` parameter
`Object` `EntityPersister.load(Serializable id, Object optionalObject, LockOptions lockOptions, SessionImplementor session)` Load an instance of the persistent class.
`Object` `UniqueKeyLoadable.loadByUniqueKey(String propertyName, Object uniqueKey, SessionImplementor session)` Load an instance of the persistent class, by a unique key other than the primary key.
`Object` `AbstractEntityPersister.loadByUniqueKey(String propertyName, Object uniqueKey, SessionImplementor session)`
`void` `AbstractEntityPersister.lock(Serializable id, Object version, Object object, LockMode lockMode, SessionImplementor session)`
`void` `EntityPersister.lock(Serializable id, Object version, Object object, LockMode lockMode, SessionImplementor session)` Do a version check (optional operation)
`void` `AbstractEntityPersister.lock(Serializable id, Object version, Object object, LockOptions lockOptions, SessionImplementor session)`
`void` `EntityPersister.lock(Serializable id, Object version, Object object, LockOptions lockOptions, SessionImplementor session)` Do a version check (optional operation)
`Object` `DiscriminatorType.nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)`
`Object` `DiscriminatorType.nullSafeGet(ResultSet rs, String name, SessionImplementor session, Object owner)`
`void` `DiscriminatorType.nullSafeSet(PreparedStatement st, Object value, int index, boolean[] settable, SessionImplementor session)`
`void` `DiscriminatorType.nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)`
`Object` `DiscriminatorType.replace(Object original, Object target, SessionImplementor session, Object owner, Map copyCache)`
`void` `DiscriminatorType.setToXMLNode(org.dom4j.Node node, Object value, SessionFactoryImplementor factory)`
`String` `DiscriminatorType.toLoggableString(Object value, SessionFactoryImplementor factory)`
`void` `AbstractEntityPersister.update(Serializable id, Object[] fields, int[] dirtyFields, boolean hasDirtyCollection, Object[] oldFields, Object oldVersion, Object object, Object rowId, SessionImplementor session)` Update an object
`void` `EntityPersister.update(Serializable id, Object[] fields, int[] dirtyFields, boolean hasDirtyCollection, Object[] oldFields, Object oldVersion, Object object, Object rowId, SessionImplementor session)` Update a persistent instance
`protected boolean` `AbstractEntityPersister.update(Serializable id, Object[] fields, Object[] oldFields, Object rowId, boolean[] includeProperty, int j, Object oldVersion, Object object, String sql, SessionImplementor session)`
`protected void` `AbstractEntityPersister.updateOrInsert(Serializable id, Object[] fields, Object[] oldFields, Object rowId, boolean[] includeProperty, int j, Object oldVersion, Object object, String sql, SessionImplementor session)` Perform an SQL UPDATE or SQL INSERT

Constructors in org.hibernate.persister.entity that throw HibernateException
`AbstractEntityPersister(EntityBinding entityBinding, EntityRegionAccessStrategy cacheAccessStrategy, NaturalIdRegionAccessStrategy naturalIdRegionAccessStrategy, SessionFactoryImplementor factory)`
`AbstractEntityPersister(PersistentClass persistentClass, EntityRegionAccessStrategy cacheAccessStrategy, NaturalIdRegionAccessStrategy naturalIdRegionAccessStrategy, SessionFactoryImplementor factory)`
`JoinedSubclassEntityPersister(EntityBinding entityBinding, EntityRegionAccessStrategy cacheAccessStrategy, NaturalIdRegionAccessStrategy naturalIdRegionAccessStrategy, SessionFactoryImplementor factory, Mapping mapping)`
`JoinedSubclassEntityPersister(PersistentClass persistentClass, EntityRegionAccessStrategy cacheAccessStrategy, NaturalIdRegionAccessStrategy naturalIdRegionAccessStrategy, SessionFactoryImplementor factory, Mapping mapping)`
`SingleTableEntityPersister(EntityBinding entityBinding, EntityRegionAccessStrategy cacheAccessStrategy, NaturalIdRegionAccessStrategy naturalIdRegionAccessStrategy, SessionFactoryImplementor factory, Mapping mapping)`
`SingleTableEntityPersister(PersistentClass persistentClass, EntityRegionAccessStrategy cacheAccessStrategy, NaturalIdRegionAccessStrategy naturalIdRegionAccessStrategy, SessionFactoryImplementor factory, Mapping mapping)`
`UnionSubclassEntityPersister(EntityBinding entityBinding, EntityRegionAccessStrategy cacheAccessStrategy, NaturalIdRegionAccessStrategy naturalIdRegionAccessStrategy, SessionFactoryImplementor factory, Mapping mapping)`
`UnionSubclassEntityPersister(PersistentClass persistentClass, EntityRegionAccessStrategy cacheAccessStrategy, NaturalIdRegionAccessStrategy naturalIdRegionAccessStrategy, SessionFactoryImplementor factory, Mapping mapping)`

Uses of HibernateException in org.hibernate.persister.internal

Methods in org.hibernate.persister.internal that throw HibernateException
`CollectionPersister` `PersisterFactoryImpl.createCollectionPersister(Configuration cfg, Collection collectionMetadata, CollectionRegionAccessStrategy cacheAccessStrategy, SessionFactoryImplementor factory)`
`CollectionPersister` `PersisterFactoryImpl.createCollectionPersister(MetadataImplementor metadata, PluralAttributeBinding collectionMetadata, CollectionRegionAccessStrategy cacheAccessStrategy, SessionFactoryImplementor factory)`

Uses of HibernateException in org.hibernate.persister.spi

Subclasses of HibernateException in org.hibernate.persister.spi
`class` `UnknownPersisterException` Indicates that the persister to use is not known and couyld not be determined.

Methods in org.hibernate.persister.spi that throw HibernateException
`CollectionPersister` `PersisterFactory.createCollectionPersister(Configuration cfg, Collection model, CollectionRegionAccessStrategy cacheAccessStrategy, SessionFactoryImplementor factory)` Create a collection persister instance.
`CollectionPersister` `PersisterFactory.createCollectionPersister(MetadataImplementor metadata, PluralAttributeBinding model, CollectionRegionAccessStrategy cacheAccessStrategy, SessionFactoryImplementor factory)` Create a collection persister instance.
`EntityPersister` `PersisterFactory.createEntityPersister(EntityBinding model, EntityRegionAccessStrategy cacheAccessStrategy, SessionFactoryImplementor factory, Mapping cfg)` Create an entity persister instance.
`EntityPersister` `PersisterFactory.createEntityPersister(PersistentClass model, EntityRegionAccessStrategy cacheAccessStrategy, NaturalIdRegionAccessStrategy naturalIdAccessStrategy, SessionFactoryImplementor factory, Mapping cfg)` Create an entity persister instance.

Uses of HibernateException in org.hibernate.property

Methods in org.hibernate.property that throw HibernateException
`Object` `EmbeddedPropertyAccessor.EmbeddedGetter.get(Object target)` Get the property value from the given instance .
`Object` `MapAccessor.MapGetter.get(Object target)` Get the property value from the given instance .
`Object` `Getter.get(Object owner)` Get the property value from the given instance .
`Object` `BasicPropertyAccessor.BasicGetter.get(Object target)` Get the property value from the given instance .
`Object` `DirectPropertyAccessor.DirectGetter.get(Object target)` Get the property value from the given instance .
`Object` `IndexPropertyAccessor.IndexGetter.getForInsert(Object target, Map mergeMap, SessionImplementor session)`
`Object` `Getter.getForInsert(Object owner, Map mergeMap, SessionImplementor session)` Get the property value from the given owner instance.
`void` `MapAccessor.MapSetter.set(Object target, Object value, SessionFactoryImplementor factory)` Set the property value from the given instance
`void` `BasicPropertyAccessor.BasicSetter.set(Object target, Object value, SessionFactoryImplementor factory)`
`void` `Setter.set(Object target, Object value, SessionFactoryImplementor factory)` Set the property value from the given instance
`void` `DirectPropertyAccessor.DirectSetter.set(Object target, Object value, SessionFactoryImplementor factory)` Set the property value from the given instance

Uses of HibernateException in org.hibernate.proxy

Methods in org.hibernate.proxy that throw HibernateException
`Object` `AbstractLazyInitializer.getImplementation(SessionImplementor s)`
`Object` `LazyInitializer.getImplementation(SessionImplementor session)` Return the underlying persistent object in the given session, or null if not contained in this session's persistence context.
`HibernateProxy` `ProxyFactory.getProxy(Serializable id, SessionImplementor session)` Create a new proxy instance
`void` `AbstractLazyInitializer.initialize()`
`void` `LazyInitializer.initialize()` Initialize the proxy, fetching the target entity if necessary.
`void` `ProxyFactory.postInstantiate(String entityName, Class persistentClass, Set interfaces, Method getIdentifierMethod, Method setIdentifierMethod, CompositeType componentIdType)` Called immediately after instantiation of this factory.
`void` `AbstractLazyInitializer.setSession(SessionImplementor s)`
`void` `LazyInitializer.setSession(SessionImplementor session)` Associate the proxy with the given session.

Uses of HibernateException in org.hibernate.proxy.dom4j

Methods in org.hibernate.proxy.dom4j that throw HibernateException
`HibernateProxy` `Dom4jProxyFactory.getProxy(Serializable id, SessionImplementor session)` Create a new proxy
`void` `Dom4jProxyFactory.postInstantiate(String entityName, Class persistentClass, Set interfaces, Method getIdentifierMethod, Method setIdentifierMethod, CompositeType componentIdType)` Called immediately after instantiation

Uses of HibernateException in org.hibernate.proxy.map

Methods in org.hibernate.proxy.map that throw HibernateException
`HibernateProxy` `MapProxyFactory.getProxy(Serializable id, SessionImplementor session)`
`void` `MapProxyFactory.postInstantiate(String entityName, Class persistentClass, Set interfaces, Method getIdentifierMethod, Method setIdentifierMethod, CompositeType componentIdType)`

Uses of HibernateException in org.hibernate.proxy.pojo.javassist

Methods in org.hibernate.proxy.pojo.javassist that throw HibernateException
`static HibernateProxy` `JavassistLazyInitializer.getProxy(Class factory, String entityName, Class persistentClass, Class[] interfaces, Method getIdentifierMethod, Method setIdentifierMethod, CompositeType componentIdType, Serializable id, SessionImplementor session, boolean classOverridesEquals)`
`HibernateProxy` `JavassistProxyFactory.getProxy(Serializable id, SessionImplementor session)`
`static HibernateProxy` `JavassistLazyInitializer.getProxy(String entityName, Class persistentClass, Class[] interfaces, Method getIdentifierMethod, Method setIdentifierMethod, CompositeType componentIdType, Serializable id, SessionImplementor session)`
`static Class` `JavassistLazyInitializer.getProxyFactory(Class persistentClass, Class[] interfaces)`
`void` `JavassistProxyFactory.postInstantiate(String entityName, Class persistentClass, Set interfaces, Method getIdentifierMethod, Method setIdentifierMethod, CompositeType componentIdType)`

Uses of HibernateException in org.hibernate.secure.internal

Constructors in org.hibernate.secure.internal that throw HibernateException
`JACCConfiguration(String contextId)`

Uses of HibernateException in org.hibernate.service

Subclasses of HibernateException in org.hibernate.service
`class` `UnknownServiceException` Indicates that an unkown service was requested from the registry.
`class` `UnknownUnwrapTypeException`

Uses of HibernateException in org.hibernate.service.classloading.spi

Subclasses of HibernateException in org.hibernate.service.classloading.spi
`class` `ClassLoadingException` Indicates a problem performing class loading

Uses of HibernateException in org.hibernate.service.internal

Subclasses of HibernateException in org.hibernate.service.internal
`class` `ServiceDependencyException` Indictes a problem processing service dependencies.
`class` `ServiceProxyGenerationException` Indicates a problem generating a service proxy

Uses of HibernateException in org.hibernate.service.jdbc.connections.internal

Methods in org.hibernate.service.jdbc.connections.internal with parameters of type HibernateException
`void` `C3P0MessageLogger_$logger.namedQueryError(String arg0, HibernateException arg1)`
`void` `ProxoolMessageLogger_$logger.namedQueryError(String arg0, HibernateException arg1)`
`void` `C3P0MessageLogger_$logger.unableToCloseSession(HibernateException arg0)`
`void` `ProxoolMessageLogger_$logger.unableToCloseSession(HibernateException arg0)`
`void` `C3P0MessageLogger_$logger.unableToCloseSessionButSwallowingError(HibernateException arg0)`
`void` `ProxoolMessageLogger_$logger.unableToCloseSessionButSwallowingError(HibernateException arg0)`
`void` `C3P0MessageLogger_$logger.unableToConfigureSqlExceptionConverter(HibernateException arg0)`
`void` `ProxoolMessageLogger_$logger.unableToConfigureSqlExceptionConverter(HibernateException arg0)`
`void` `C3P0MessageLogger_$logger.unableToCreateProxyFactory(String arg0, HibernateException arg1)`
`void` `ProxoolMessageLogger_$logger.unableToCreateProxyFactory(String arg0, HibernateException arg1)`
`void` `C3P0MessageLogger_$logger.unableToLoadCommand(HibernateException arg0)`
`void` `ProxoolMessageLogger_$logger.unableToLoadCommand(HibernateException arg0)`
`void` `C3P0MessageLogger_$logger.unableToSynchronizeDatabaseStateWithSession(HibernateException arg0)`
`void` `ProxoolMessageLogger_$logger.unableToSynchronizeDatabaseStateWithSession(HibernateException arg0)`

Methods in org.hibernate.service.jdbc.connections.internal that throw HibernateException
`void` `ProxoolConnectionProvider.close()` Release all resources held by this provider.
`void` `ProxoolConnectionProvider.configure(Properties props)` Initialize the connection provider from given properties.

Uses of HibernateException in org.hibernate.service.jdbc.dialect.internal

Methods in org.hibernate.service.jdbc.dialect.internal that throw HibernateException
`Dialect` `DialectFactoryImpl.buildDialect(Map configValues, Connection connection)`

Uses of HibernateException in org.hibernate.service.jdbc.dialect.spi

Methods in org.hibernate.service.jdbc.dialect.spi that throw HibernateException
`Dialect` `DialectFactory.buildDialect(Map configValues, Connection connection)` Builds an appropriate Dialect instance.

Uses of HibernateException in org.hibernate.service.jndi

Subclasses of HibernateException in org.hibernate.service.jndi
`class` `JndiException` An exception indicating trouble accessing JNDI
`class` `JndiNameException` Indicates a problem with a given JNDI name being deemed as not valid.

Uses of HibernateException in org.hibernate.service.jta.platform.spi

Subclasses of HibernateException in org.hibernate.service.jta.platform.spi
`class` `JtaPlatformException` Indicates a problem interacting with the underlying JTA platform.

Uses of HibernateException in org.hibernate.service.spi

Subclasses of HibernateException in org.hibernate.service.spi
`class` `ServiceException` Indicates a problem with a service.

Uses of HibernateException in org.hibernate.sql.ordering.antlr

Methods in org.hibernate.sql.ordering.antlr that throw HibernateException
`String[]` `ColumnMapper.map(String reference)` Resolve the property reference to its underlying columns.

Uses of HibernateException in org.hibernate.testing.junit4

Methods in org.hibernate.testing.junit4 that throw HibernateException
`protected Session` `BaseCoreFunctionalTestCase.openSession()`
`protected Session` `BaseCoreFunctionalTestCase.openSession(Interceptor interceptor)`

Uses of HibernateException in org.hibernate.tool

Constructors in org.hibernate.tool that throw HibernateException
`EnversSchemaGenerator(Configuration configuration, Connection connection)`
`EnversSchemaGenerator(Configuration configuration, Properties properties)`

Uses of HibernateException in org.hibernate.tool.hbm2ddl

Subclasses of HibernateException in org.hibernate.tool.hbm2ddl
`class` `ImportScriptException`

Methods in org.hibernate.tool.hbm2ddl that throw HibernateException
`TableMetadata` `DatabaseMetadata.getTableMetadata(String name, String schema, String catalog, boolean isQuoted)`
`boolean` `DatabaseMetadata.isTable(Object key)`

Constructors in org.hibernate.tool.hbm2ddl that throw HibernateException
`SchemaExport(Configuration configuration, Connection connection)` Create a schema exporter for the given Configuration, using the supplied connection for connectivity.
`SchemaExport(Configuration configuration, Properties properties)` Deprecated. properties may be specified via the Configuration object
`SchemaUpdate(Configuration cfg)`
`SchemaUpdate(Configuration configuration, Properties properties)`
`SchemaUpdate(ServiceRegistry serviceRegistry, Configuration cfg)`
`SchemaValidator(Configuration cfg)`
`SchemaValidator(Configuration cfg, Properties connectionProperties)`
`SchemaValidator(ServiceRegistry serviceRegistry, Configuration cfg)`

Uses of HibernateException in org.hibernate.transaction

Methods in org.hibernate.transaction that throw HibernateException
`TransactionManager` `TransactionManagerLookup.getTransactionManager(Properties props)` Obtain the JTA `TransactionManager`.

Uses of HibernateException in org.hibernate.tuple.component

Methods in org.hibernate.tuple.component that throw HibernateException
`Object` `AbstractComponentTuplizer.getPropertyValue(Object component, int i)`
`Object[]` `PojoComponentTuplizer.getPropertyValues(Object component)`
`Object[]` `AbstractComponentTuplizer.getPropertyValues(Object component)`
`Object` `AbstractComponentTuplizer.instantiate()` This method does not populate the component parent
`void` `PojoComponentTuplizer.setPropertyValues(Object component, Object[] values)`
`void` `AbstractComponentTuplizer.setPropertyValues(Object component, Object[] values)`

Uses of HibernateException in org.hibernate.tuple.entity

Methods in org.hibernate.tuple.entity that throw HibernateException
`Object` `EntityTuplizer.createProxy(Serializable id, SessionImplementor session)` Generates an appropriate proxy representation of this entity for this entity-mode.
`Object` `AbstractEntityTuplizer.createProxy(Serializable id, SessionImplementor session)`
`Serializable` `EntityTuplizer.getIdentifier(Object entity)` Deprecated. Use `EntityTuplizer.getIdentifier(Object,SessionImplementor)` instead.
`Serializable` `AbstractEntityTuplizer.getIdentifier(Object entity)`
`Object` `AbstractEntityTuplizer.getPropertyValue(Object entity, int i)`
`Object` `EntityTuplizer.getPropertyValue(Object entity, String propertyName)` Extract the value of a particular property from the given entity.
`Object` `AbstractEntityTuplizer.getPropertyValue(Object entity, String propertyPath)`
`Object[]` `PojoEntityTuplizer.getPropertyValues(Object entity)` Extract the current values contained on the given entity.
`Object[]` `AbstractEntityTuplizer.getPropertyValues(Object entity)`
`Object[]` `EntityTuplizer.getPropertyValuesToInsert(Object entity, Map mergeMap, SessionImplementor session)` Extract the values of the insertable properties of the entity (including backrefs)
`Object[]` `PojoEntityTuplizer.getPropertyValuesToInsert(Object entity, Map mergeMap, SessionImplementor session)` Extract the values of the insertable properties of the entity (including backrefs)
`Object[]` `AbstractEntityTuplizer.getPropertyValuesToInsert(Object entity, Map mergeMap, SessionImplementor session)`
`Object` `EntityTuplizer.getVersion(Object entity)` Extract the value of the version property from the given entity.
`Object` `AbstractEntityTuplizer.getVersion(Object entity)`
`Object` `AbstractEntityTuplizer.instantiate()`
`Object` `EntityTuplizer.instantiate(Serializable id)` Deprecated. Use `EntityTuplizer.instantiate(Serializable, SessionImplementor)` instead.
`Object` `AbstractEntityTuplizer.instantiate(Serializable id)`
`void` `EntityTuplizer.setIdentifier(Object entity, Serializable id)` Deprecated. Use `EntityTuplizer.setIdentifier(Object, Serializable, SessionImplementor)` instead.
`void` `AbstractEntityTuplizer.setIdentifier(Object entity, Serializable id)` Inject the identifier value into the given entity.
`void` `EntityTuplizer.setPropertyValue(Object entity, int i, Object value)` Inject the value of a particular property.
`void` `AbstractEntityTuplizer.setPropertyValue(Object entity, int i, Object value)`
`void` `EntityTuplizer.setPropertyValue(Object entity, String propertyName, Object value)` Inject the value of a particular property.
`void` `AbstractEntityTuplizer.setPropertyValue(Object entity, String propertyName, Object value)`
`void` `PojoEntityTuplizer.setPropertyValues(Object entity, Object[] values)` Inject the given values into the given entity.
`void` `AbstractEntityTuplizer.setPropertyValues(Object entity, Object[] values)`

Uses of HibernateException in org.hibernate.type

Subclasses of HibernateException in org.hibernate.type
`class` `SerializationException` Thrown when a property cannot be serializaed/deserialized

Methods in org.hibernate.type that throw HibernateException
`Object` `EnumType.assemble(Serializable cached, Object owner)`
`Object` `StringClobType.assemble(Serializable cached, Object owner)` Deprecated.
`Object` `ComponentType.assemble(Serializable object, SessionImplementor session, Object owner)`
`Object` `Type.assemble(Serializable cached, SessionImplementor session, Object owner)` Reconstruct the object from its disassembled state.
`Object` `AnyType.assemble(Serializable cached, SessionImplementor session, Object owner)`
`Object` `CompositeCustomType.assemble(Serializable cached, SessionImplementor session, Object owner)`
`Object` `AbstractStandardBasicType.assemble(Serializable cached, SessionImplementor session, Object owner)`
`Object` `ManyToOneType.assemble(Serializable oid, SessionImplementor session, Object owner)`
`Object` `SpecialOneToOneType.assemble(Serializable oid, SessionImplementor session, Object owner)`
`Object` `AbstractType.assemble(Serializable cached, SessionImplementor session, Object owner)`
`Object` `CustomType.assemble(Serializable cached, SessionImplementor session, Object owner)`
`Object` `CollectionType.assemble(Serializable cached, SessionImplementor session, Object owner)`
`Object` `OneToOneType.assemble(Serializable oid, SessionImplementor session, Object owner)`
`Object` `EnumType.deepCopy(Object value)`
`Object` `StringClobType.deepCopy(Object value)` Deprecated.
`Object` `ComponentType.deepCopy(Object component, SessionFactoryImplementor factory)`
`Object` `Type.deepCopy(Object value, SessionFactoryImplementor factory)` Return a deep copy of the persistent state, stopping at entities and at collections.
`Object` `AnyType.deepCopy(Object value, SessionFactoryImplementor factory)`
`Object` `MetaType.deepCopy(Object value, SessionFactoryImplementor factory)`
`Object` `CompositeCustomType.deepCopy(Object value, SessionFactoryImplementor factory)`
`Object` `ByteArrayBlobType.deepCopy(Object value, SessionFactoryImplementor factory)` Deprecated.
`Object` `CustomType.deepCopy(Object value, SessionFactoryImplementor factory)`
`Object` `MutableType.deepCopy(Object value, SessionFactoryImplementor factory)` Deprecated.
`Object` `SerializableToBlobType.deepCopy(Object value, SessionFactoryImplementor factory)`
`Object` `CollectionType.deepCopy(Object value, SessionFactoryImplementor factory)`
`protected abstract Object` `MutableType.deepCopyNotNull(Object value)` Deprecated.
`protected Object` `AbstractCharArrayType.deepCopyNotNull(Object value)` Deprecated.
`Serializable` `EnumType.disassemble(Object value)`
`Serializable` `StringClobType.disassemble(Object value)` Deprecated.
`Serializable` `ComponentType.disassemble(Object value, SessionImplementor session, Object owner)`
`Serializable` `Type.disassemble(Object value, SessionImplementor session, Object owner)` Return a disassembled representation of the object.
`Serializable` `AnyType.disassemble(Object value, SessionImplementor session, Object owner)`
`Serializable` `CompositeCustomType.disassemble(Object value, SessionImplementor session, Object owner)`
`Serializable` `AbstractStandardBasicType.disassemble(Object value, SessionImplementor session, Object owner)`
`Serializable` `ManyToOneType.disassemble(Object value, SessionImplementor session, Object owner)`
`Serializable` `SpecialOneToOneType.disassemble(Object value, SessionImplementor session, Object owner)`
`Serializable` `AbstractType.disassemble(Object value, SessionImplementor session, Object owner)`
`Serializable` `CustomType.disassemble(Object value, SessionImplementor session, Object owner)`
`Serializable` `CollectionType.disassemble(Object value, SessionImplementor session, Object owner)`
`Serializable` `OneToOneType.disassemble(Object value, SessionImplementor session, Object owner)`
`boolean` `EnumType.equals(Object x, Object y)`
`boolean` `StringClobType.equals(Object x, Object y)` Deprecated.
`T` `AbstractStandardBasicType.fromStringValue(String xml)`
`abstract Object` `NullableType.fromStringValue(String xml)` Deprecated.
`Object` `AbstractBynaryType.fromStringValue(String xml)` Deprecated.
`T` `SingleColumnType.fromStringValue(String xml)`
`Date` `TimestampType.fromStringValue(String xml)`
`T` `StringRepresentableType.fromStringValue(String string)` Consume the given string representation back into this types java form.
`Object` `ComponentType.fromXMLNode(org.dom4j.Node xml, Mapping factory)`
`Object` `Type.fromXMLNode(org.dom4j.Node xml, Mapping factory)` Parse the XML representation of an instance.
`Object` `AnyType.fromXMLNode(org.dom4j.Node xml, Mapping factory)`
`Object` `MetaType.fromXMLNode(org.dom4j.Node xml, Mapping factory)`
`Object` `CompositeCustomType.fromXMLNode(org.dom4j.Node xml, Mapping factory)`
`Object` `NullableType.fromXMLNode(org.dom4j.Node xml, Mapping factory)` Deprecated.
`Object` `ByteArrayBlobType.fromXMLNode(org.dom4j.Node xml, Mapping factory)` Deprecated.
`Object` `CustomType.fromXMLNode(org.dom4j.Node xml, Mapping factory)`
`Object` `SerializableToBlobType.fromXMLNode(org.dom4j.Node xml, Mapping factory)`
`Object` `CollectionType.fromXMLNode(org.dom4j.Node xml, Mapping factory)`
`Object` `EntityType.fromXMLNode(org.dom4j.Node xml, Mapping factory)` Parse the XML representation of an instance.
`Object` `MetaType.fromXMLString(String xml, Mapping factory)`
`T` `AbstractStandardBasicType.fromXMLString(String xml, Mapping factory)`
`Object` `NullableType.fromXMLString(String xml, Mapping factory)` Deprecated.
`T` `XmlRepresentableType.fromXMLString(String xml, Mapping factory)`
`abstract Object` `NullableType.get(ResultSet rs, String name)` Deprecated. Get a column value from a result set, without worrying about the possibility of null values.
`Object` `AbstractBynaryType.get(ResultSet rs, String name)` Deprecated.
`Object` `AbstractLongStringType.get(ResultSet rs, String name)` Deprecated.
`Object` `AbstractStandardBasicType.get(ResultSet rs, String name, SessionImplementor session)`
`Object` `SingleColumnType.get(ResultSet rs, String name, SessionImplementor session)` Get a column value from a result set, without worrying about the possibility of null values.
`int` `Type.getHashCode(Object x)` Get a hash code, consistent with persistence "equality".
`int` `Type.getHashCode(Object x, SessionFactoryImplementor factory)` Get a hash code, consistent with persistence "equality".
`protected Object` `EntityType.getIdentifier(Object value, SessionImplementor session)`
`Object` `CompositeCustomType.getPropertyValue(Object component, int i)`
`Object` `ComponentType.getPropertyValue(Object component, int i, EntityMode entityMode)`
`Object` `ComponentType.getPropertyValue(Object component, int i, SessionImplementor session)`
`Object` `CompositeType.getPropertyValue(Object component, int index, SessionImplementor session)` Extract a particular component property value indicated by index.
`Object` `AnyType.getPropertyValue(Object component, int i, SessionImplementor session)`
`Object` `CompositeCustomType.getPropertyValue(Object component, int i, SessionImplementor session)`
`Object[]` `ComponentType.getPropertyValues(Object component, EntityMode entityMode)`
`Object[]` `CompositeType.getPropertyValues(Object component, EntityMode entityMode)` Extract the values of the component properties from the given component instance without access to the session.
`Object[]` `CompositeCustomType.getPropertyValues(Object component, EntityMode entityMode)`
`Object[]` `ComponentType.getPropertyValues(Object component, SessionImplementor session)`
`Object[]` `CompositeType.getPropertyValues(Object component, SessionImplementor session)` Extract the values of the component properties from the given component instance
`Object[]` `AnyType.getPropertyValues(Object component, SessionImplementor session)`
`Object[]` `CompositeCustomType.getPropertyValues(Object component, SessionImplementor session)`
`int` `EnumType.hashCode(Object x)`
`int` `StringClobType.hashCode(Object x)` Deprecated.
`Object` `ComponentType.hydrate(ResultSet rs, String[] names, SessionImplementor session, Object owner)`
`Object` `Type.hydrate(ResultSet rs, String[] names, SessionImplementor session, Object owner)` Extract a value from the JDBC result set.
`Object` `AnyType.hydrate(ResultSet rs, String[] names, SessionImplementor session, Object owner)`
`Object` `AbstractStandardBasicType.hydrate(ResultSet rs, String[] names, SessionImplementor session, Object owner)`
`Object` `ManyToOneType.hydrate(ResultSet rs, String[] names, SessionImplementor session, Object owner)`
`Object` `SpecialOneToOneType.hydrate(ResultSet rs, String[] names, SessionImplementor session, Object owner)`
`Object` `AbstractType.hydrate(ResultSet rs, String[] names, SessionImplementor session, Object owner)`
`Object` `OneToOneType.hydrate(ResultSet rs, String[] names, SessionImplementor session, Object owner)`
`Object` `ComponentType.instantiate(EntityMode entityMode)` This method does not populate the component parent
`Object` `ComponentType.instantiate(Object parent, SessionImplementor session)`
`Object` `EmbeddedComponentType.instantiate(Object parent, SessionImplementor session)`
`PersistentCollection` `ArrayType.instantiate(SessionImplementor session, CollectionPersister persister, Serializable key)`
`PersistentCollection` `BagType.instantiate(SessionImplementor session, CollectionPersister persister, Serializable key)`
`PersistentCollection` `IdentifierBagType.instantiate(SessionImplementor session, CollectionPersister persister, Serializable key)`
`PersistentCollection` `CustomCollectionType.instantiate(SessionImplementor session, CollectionPersister persister, Serializable key)`
`boolean` `ComponentType.isDirty(Object x, Object y, boolean[] checkable, SessionImplementor session)`
`boolean` `Type.isDirty(Object oldState, Object currentState, boolean[] checkable, SessionImplementor session)` Should the parent be considered dirty, given both the old and current value?
`boolean` `AnyType.isDirty(Object old, Object current, boolean[] checkable, SessionImplementor session)`
`boolean` `MetaType.isDirty(Object old, Object current, boolean[] checkable, SessionImplementor session)`
`boolean` `CompositeCustomType.isDirty(Object old, Object current, boolean[] checkable, SessionImplementor session)`
`boolean` `ManyToOneType.isDirty(Object old, Object current, boolean[] checkable, SessionImplementor session)`
`boolean` `NullableType.isDirty(Object old, Object current, boolean[] checkable, SessionImplementor session)` Deprecated.
`boolean` `CustomType.isDirty(Object old, Object current, boolean[] checkable, SessionImplementor session)`
`boolean` `CollectionType.isDirty(Object old, Object current, boolean[] checkable, SessionImplementor session)`
`boolean` `AbstractLobType.isDirty(Object old, Object current, boolean[] checkable, SessionImplementor session)` Deprecated.
`boolean` `ComponentType.isDirty(Object x, Object y, SessionImplementor session)`
`boolean` `Type.isDirty(Object old, Object current, SessionImplementor session)` Should the parent be considered dirty, given both the old and current value?
`boolean` `ManyToOneType.isDirty(Object old, Object current, SessionImplementor session)`
`boolean` `AbstractType.isDirty(Object old, Object current, SessionImplementor session)`
`boolean` `CollectionType.isDirty(Object old, Object current, SessionImplementor session)`
`boolean` `ComponentType.isEqual(Object x, Object y)`
`boolean` `Type.isEqual(Object x, Object y)` Compare two instances of the class mapped by this type for persistence "equality" (equality of persistent state).
`boolean` `CompositeCustomType.isEqual(Object x, Object y)`
`boolean` `CustomType.isEqual(Object x, Object y)`
`boolean` `ComponentType.isEqual(Object x, Object y, SessionFactoryImplementor factory)`
`boolean` `Type.isEqual(Object x, Object y, SessionFactoryImplementor factory)` Compare two instances of the class mapped by this type for persistence "equality" (equality of persistent state).
`boolean` `ComponentType.isModified(Object old, Object current, boolean[] checkable, SessionImplementor session)`
`boolean` `Type.isModified(Object dbState, Object currentState, boolean[] checkable, SessionImplementor session)` Has the value been modified compared to the current database state? The difference between this and the `Type.isDirty(java.lang.Object, java.lang.Object, org.hibernate.engine.spi.SessionImplementor)` methods is that here we need to account for "partially" built values.
`boolean` `AnyType.isModified(Object old, Object current, boolean[] checkable, SessionImplementor session)`
`boolean` `ManyToOneType.isModified(Object old, Object current, boolean[] checkable, SessionImplementor session)`
`boolean` `AbstractType.isModified(Object old, Object current, boolean[] checkable, SessionImplementor session)`
`boolean` `CollectionType.isModified(Object old, Object current, boolean[] checkable, SessionImplementor session)`
`boolean` `ComponentType.isSame(Object x, Object y)`
`boolean` `Type.isSame(Object x, Object y)` Compare two instances of the class mapped by this type for persistence "equality" (equality of persistent state) taking a shortcut for entity references.
`boolean` `AnyType.isSame(Object x, Object y)`
`boolean` `AbstractType.isSame(Object x, Object y)`
`Object` `EntityType.loadByUniqueKey(String entityName, String uniqueKeyPropertyName, Object key, SessionImplementor session)` Load an instance by a unique key that is not the primary key.
`Object` `NullableType.nullSafeGet(ResultSet rs, String name)` Deprecated.
`Object` `NullableType.nullSafeGet(ResultSet rs, String[] names)` Deprecated.
`Object` `ComponentType.nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)`
`Object` `Type.nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)` Extract a value of the `mapped class` from the JDBC result set.
`Object` `AnyType.nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)`
`Object` `MetaType.nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)`
`Object` `CompositeCustomType.nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)`
`Object` `NullableType.nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)` Deprecated.
`Object` `EnumType.nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)`
`Object` `CustomType.nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)`
`Object` `StringClobType.nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)` Deprecated.
`Object` `CollectionType.nullSafeGet(ResultSet rs, String[] name, SessionImplementor session, Object owner)`
`Object` `EntityType.nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)` Extract a value of the `mapped class` from the JDBC result set.
`Object` `AbstractLobType.nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)` Deprecated.
`T` `SingleColumnType.nullSafeGet(ResultSet rs, String name, SessionImplementor session)` Get a column value from a result set by name.
`Object` `ComponentType.nullSafeGet(ResultSet rs, String name, SessionImplementor session, Object owner)`
`Object` `Type.nullSafeGet(ResultSet rs, String name, SessionImplementor session, Object owner)` Extract a value of the `mapped class` from the JDBC result set.
`Object` `AnyType.nullSafeGet(ResultSet rs, String name, SessionImplementor session, Object owner)`
`Object` `MetaType.nullSafeGet(ResultSet rs, String name, SessionImplementor session, Object owner)`
`Object` `CompositeCustomType.nullSafeGet(ResultSet rs, String columnName, SessionImplementor session, Object owner)`
`Object` `NullableType.nullSafeGet(ResultSet rs, String name, SessionImplementor session, Object owner)` Deprecated.
`Object` `CustomType.nullSafeGet(ResultSet rs, String columnName, SessionImplementor session, Object owner)`
`Object` `EntityType.nullSafeGet(ResultSet rs, String name, SessionImplementor session, Object owner)` Extract a value of the `mapped class` from the JDBC result set.
`Object` `AbstractLobType.nullSafeGet(ResultSet rs, String name, SessionImplementor session, Object owner)` Deprecated.
`void` `NullableType.nullSafeSet(PreparedStatement st, Object value, int index)` Deprecated.
`void` `ComponentType.nullSafeSet(PreparedStatement st, Object value, int begin, boolean[] settable, SessionImplementor session)`
`void` `Type.nullSafeSet(PreparedStatement st, Object value, int index, boolean[] settable, SessionImplementor session)` Bind a value represented by an instance of the `mapped class` to the JDBC prepared statement, ignoring some columns as dictated by the 'settable' parameter.
`void` `AnyType.nullSafeSet(PreparedStatement st, Object value, int index, boolean[] settable, SessionImplementor session)`
`void` `MetaType.nullSafeSet(PreparedStatement st, Object value, int index, boolean[] settable, SessionImplementor session)`
`void` `AbstractSingleColumnStandardBasicType.nullSafeSet(PreparedStatement st, Object value, int index, boolean[] settable, SessionImplementor session)` Bind a value represented by an instance of the `mapped class` to the JDBC prepared statement, ignoring some columns as dictated by the 'settable' parameter.
`void` `CompositeCustomType.nullSafeSet(PreparedStatement st, Object value, int index, boolean[] settable, SessionImplementor session)`
`void` `ManyToOneType.nullSafeSet(PreparedStatement st, Object value, int index, boolean[] settable, SessionImplementor session)`
`void` `NullableType.nullSafeSet(PreparedStatement st, Object value, int index, boolean[] settable, SessionImplementor session)` Deprecated.
`void` `CustomType.nullSafeSet(PreparedStatement st, Object value, int index, boolean[] settable, SessionImplementor session)`
`void` `CollectionType.nullSafeSet(PreparedStatement st, Object value, int index, boolean[] settable, SessionImplementor session)`
`void` `AbstractLobType.nullSafeSet(PreparedStatement st, Object value, int index, boolean[] settable, SessionImplementor session)` Deprecated.
`void` `ComponentType.nullSafeSet(PreparedStatement st, Object value, int begin, SessionImplementor session)`
`void` `Type.nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)` Bind a value represented by an instance of the `mapped class` to the JDBC prepared statement.
`void` `AnyType.nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)`
`void` `MetaType.nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)`
`void` `CompositeCustomType.nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)`
`void` `ManyToOneType.nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)`
`void` `NullableType.nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)` Deprecated.
`void` `EnumType.nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)`
`void` `CustomType.nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)`
`void` `StringClobType.nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)` Deprecated.
`void` `CollectionType.nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)`
`void` `AbstractLobType.nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)` Deprecated.
`String` `NullableType.nullSafeToString(Object value)` Deprecated. A null-safe version of `NullableType.toString(Object)`.
`protected String` `CollectionType.renderLoggableString(Object value, SessionFactoryImplementor factory)`
`protected String` `CustomCollectionType.renderLoggableString(Object value, SessionFactoryImplementor factory)`
`Object` `EnumType.replace(Object original, Object target, Object owner)`
`Object` `StringClobType.replace(Object original, Object target, Object owner)` Deprecated.
`Object` `ComponentType.replace(Object original, Object target, SessionImplementor session, Object owner, Map copyCache)`
`Object` `Type.replace(Object original, Object target, SessionImplementor session, Object owner, Map copyCache)` During merge, replace the existing (target) value in the entity we are merging to with a new (original) value from the detached entity we are merging.
`Object` `AnyType.replace(Object original, Object target, SessionImplementor session, Object owner, Map copyCache)`
`Object` `CompositeCustomType.replace(Object original, Object target, SessionImplementor session, Object owner, Map copyCache)`
`Object` `ByteArrayBlobType.replace(Object original, Object target, SessionImplementor session, Object owner, Map copyCache)` Deprecated.
`Object` `CustomType.replace(Object original, Object target, SessionImplementor session, Object owner, Map copyCache)`
`Object` `MutableType.replace(Object original, Object target, SessionImplementor session, Object owner, Map copyCache)` Deprecated.
`Object` `SerializableToBlobType.replace(Object original, Object target, SessionImplementor session, Object owner, Map copyCache)`
`Object` `ImmutableType.replace(Object original, Object target, SessionImplementor session, Object owner, Map copyCache)` Deprecated.
`Object` `CollectionType.replace(Object original, Object target, SessionImplementor session, Object owner, Map copyCache)` During merge, replace the existing (target) value in the entity we are merging to with a new (original) value from the detached entity we are merging.
`Object` `EntityType.replace(Object original, Object target, SessionImplementor session, Object owner, Map copyCache)` During merge, replace the existing (target) value in the entity we are merging to with a new (original) value from the detached entity we are merging.
`Object` `ComponentType.replace(Object original, Object target, SessionImplementor session, Object owner, Map copyCache, ForeignKeyDirection foreignKeyDirection)`
`Object` `Type.replace(Object original, Object target, SessionImplementor session, Object owner, Map copyCache, ForeignKeyDirection foreignKeyDirection)` During merge, replace the existing (target) value in the entity we are merging to with a new (original) value from the detached entity we are merging.
`Object` `AbstractType.replace(Object original, Object target, SessionImplementor session, Object owner, Map copyCache, ForeignKeyDirection foreignKeyDirection)`
`Object` `MapType.replaceElements(Object original, Object target, Object owner, Map copyCache, SessionImplementor session)`
`Object` `ArrayType.replaceElements(Object original, Object target, Object owner, Map copyCache, SessionImplementor session)`
`Object` `CustomCollectionType.replaceElements(Object original, Object target, Object owner, Map copyCache, SessionImplementor session)`
`Object` `ComponentType.resolve(Object value, SessionImplementor session, Object owner)`
`Object` `Type.resolve(Object value, SessionImplementor session, Object owner)` The second phase of 2-phase loading.
`Object` `AnyType.resolve(Object value, SessionImplementor session, Object owner)`
`Object` `AbstractStandardBasicType.resolve(Object value, SessionImplementor session, Object owner)`
`Object` `AbstractType.resolve(Object value, SessionImplementor session, Object owner)`
`Object` `CollectionType.resolve(Object value, SessionImplementor session, Object owner)`
`Object` `EntityType.resolve(Object value, SessionImplementor session, Object owner)` Resolve an identifier or unique key value
`protected Object` `EntityType.resolveIdentifier(Serializable id, SessionImplementor session)` Resolve an identifier via a load.
`Object` `ComponentType.semiResolve(Object value, SessionImplementor session, Object owner)`
`Object` `Type.semiResolve(Object value, SessionImplementor session, Object owner)` Given a hydrated, but unresolved value, return a value that may be used to reconstruct property-ref associations.
`Object` `AnyType.semiResolve(Object value, SessionImplementor session, Object owner)`
`Object` `AbstractStandardBasicType.semiResolve(Object value, SessionImplementor session, Object owner)`
`Object` `AbstractType.semiResolve(Object value, SessionImplementor session, Object owner)`
`Object` `CollectionType.semiResolve(Object value, SessionImplementor session, Object owner)`
`abstract void` `NullableType.set(PreparedStatement st, Object value, int index)` Deprecated. Set a parameter value without worrying about the possibility of null values.
`void` `AbstractBynaryType.set(PreparedStatement st, Object value, int index)` Deprecated.
`void` `AbstractLongStringType.set(PreparedStatement st, Object value, int index)` Deprecated.
`void` `AbstractStandardBasicType.set(PreparedStatement st, T value, int index, SessionImplementor session)`
`void` `SingleColumnType.set(PreparedStatement st, T value, int index, SessionImplementor session)` Set a parameter value without worrying about the possibility of null values.
`void` `ComponentType.setPropertyValues(Object component, Object[] values, EntityMode entityMode)`
`void` `CompositeType.setPropertyValues(Object component, Object[] values, EntityMode entityMode)` Inject property values onto the given component instance An optional operation
`void` `AnyType.setPropertyValues(Object component, Object[] values, EntityMode entityMode)`
`void` `CompositeCustomType.setPropertyValues(Object component, Object[] values, EntityMode entityMode)`
`void` `ComponentType.setToXMLNode(org.dom4j.Node node, Object value, SessionFactoryImplementor factory)`
`void` `Type.setToXMLNode(org.dom4j.Node node, Object value, SessionFactoryImplementor factory)` A representation of the value to be embedded in an XML element.
`void` `MetaType.setToXMLNode(org.dom4j.Node node, Object value, SessionFactoryImplementor factory)`
`void` `CompositeCustomType.setToXMLNode(org.dom4j.Node node, Object value, SessionFactoryImplementor factory)`
`void` `NullableType.setToXMLNode(org.dom4j.Node xml, Object value, SessionFactoryImplementor factory)` Deprecated.
`void` `ByteArrayBlobType.setToXMLNode(org.dom4j.Node node, Object value, SessionFactoryImplementor factory)` Deprecated.
`void` `CustomType.setToXMLNode(org.dom4j.Node node, Object value, SessionFactoryImplementor factory)`
`void` `SerializableToBlobType.setToXMLNode(org.dom4j.Node node, Object value, SessionFactoryImplementor factory)`
`void` `CollectionType.setToXMLNode(org.dom4j.Node node, Object value, SessionFactoryImplementor factory)`
`void` `EntityType.setToXMLNode(org.dom4j.Node node, Object value, SessionFactoryImplementor factory)` A representation of the value to be embedded in an XML element.
`String` `ComponentType.toLoggableString(Object value, SessionFactoryImplementor factory)`
`String` `Type.toLoggableString(Object value, SessionFactoryImplementor factory)` Generate a representation of the value for logging purposes.
`String` `AnyType.toLoggableString(Object value, SessionFactoryImplementor factory)`
`String` `MetaType.toLoggableString(Object value, SessionFactoryImplementor factory)`
`String` `CompositeCustomType.toLoggableString(Object value, SessionFactoryImplementor factory)`
`String` `ArrayType.toLoggableString(Object value, SessionFactoryImplementor factory)`
`String` `CustomType.toLoggableString(Object value, SessionFactoryImplementor factory)`
`String` `SerializableToBlobType.toLoggableString(Object value, SessionFactoryImplementor factory)`
`String` `CollectionType.toLoggableString(Object value, SessionFactoryImplementor factory)`
`abstract String` `NullableType.toString(Object value)` Deprecated.
`String` `SingleColumnType.toString(T value)`
`String` `StringRepresentableType.toString(T value)` Render the value to the string representation.
`String` `MetaType.toXMLString(Object value, SessionFactoryImplementor factory)`
`String` `NullableType.toXMLString(Object value, SessionFactoryImplementor pc)` Deprecated.
`String` `AbstractStandardBasicType.toXMLString(T value, SessionFactoryImplementor factory)`
`String` `XmlRepresentableType.toXMLString(T value, SessionFactoryImplementor factory)`

Uses of HibernateException in org.hibernate.type.descriptor.java

Methods in org.hibernate.type.descriptor.java that return HibernateException
`protected HibernateException` `AbstractTypeDescriptor.unknownUnwrap(Class conversionType)`
`protected HibernateException` `AbstractTypeDescriptor.unknownWrap(Class conversionType)`

Uses of HibernateException in org.hibernate.usertype

Methods in org.hibernate.usertype that throw HibernateException
`Object` `UserType.assemble(Serializable cached, Object owner)` Reconstruct an object from the cacheable representation.
`Object` `CompositeUserType.assemble(Serializable cached, SessionImplementor session, Object owner)` Reconstruct an object from the cacheable representation.
`Object` `CompositeUserType.deepCopy(Object value)` Return a deep copy of the persistent state, stopping at entities and at collections.
`Object` `UserType.deepCopy(Object value)` Return a deep copy of the persistent state, stopping at entities and at collections.
`Serializable` `UserType.disassemble(Object value)` Transform the object into its cacheable representation.
`Serializable` `CompositeUserType.disassemble(Object value, SessionImplementor session)` Transform the object into its cacheable representation.
`boolean` `CompositeUserType.equals(Object x, Object y)` Compare two instances of the class mapped by this type for persistence "equality".
`boolean` `UserType.equals(Object x, Object y)` Compare two instances of the class mapped by this type for persistence "equality".
`Object` `CompositeUserType.getPropertyValue(Object component, int property)` Get the value of a property.
`int` `CompositeUserType.hashCode(Object x)` Get a hashcode for the instance, consistent with persistence "equality"
`int` `UserType.hashCode(Object x)` Get a hashcode for the instance, consistent with persistence "equality"
`PersistentCollection` `UserCollectionType.instantiate(SessionImplementor session, CollectionPersister persister)` Instantiate an uninitialized instance of the collection wrapper
`Object` `CompositeUserType.nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)` Retrieve an instance of the mapped class from a JDBC resultset.
`Object` `UserType.nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)` Retrieve an instance of the mapped class from a JDBC resultset.
`void` `CompositeUserType.nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)` Write an instance of the mapped class to a prepared statement.
`void` `UserType.nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)` Write an instance of the mapped class to a prepared statement.
`Object` `UserType.replace(Object original, Object target, Object owner)` During merge, replace the existing (target) value in the entity we are merging to with a new (original) value from the detached entity we are merging.
`Object` `CompositeUserType.replace(Object original, Object target, SessionImplementor session, Object owner)` During merge, replace the existing (target) value in the entity we are merging to with a new (original) value from the detached entity we are merging.
`Object` `UserCollectionType.replaceElements(Object original, Object target, CollectionPersister persister, Object owner, Map copyCache, SessionImplementor session)` Replace the elements of a collection with the elements of another collection
`void` `CompositeUserType.setPropertyValue(Object component, int property, Object value)` Set the value of a property.

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