## Uses of Class
org.hibernate.HibernateException

Packages that use HibernateException
org.hibernate: This package defines the central Hibernate APIs.
org.hibernate.action: This package defines "actions" that are scheduled for asycnchronous execution by the event listeners.
org.hibernate.cache: This package defines APIs/SPIs and implementations for the Hibernate second-level cache.
org.hibernate.cache.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.classic: This package implements backward-compatibility with Hibernate 2.1 APIs now deprecated in Hibernate3.
org.hibernate.collection: This package defines a framework for collection wrappers.
org.hibernate.connection: This package abstracts the mechanism for obtaining a JDBC connection.
org.hibernate.context
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.resolver
org.hibernate.ejb
org.hibernate.ejb.connection
org.hibernate.ejb.transaction
org.hibernate.engine: This package contains classes that are "shared" by other packages, and implementations of some key algorithms.
org.hibernate.engine.query
org.hibernate.engine.transaction
org.hibernate.envers
org.hibernate.envers.entities
org.hibernate.envers.entities.mapper.relation.lazy
org.hibernate.envers.exception
org.hibernate.envers.reader
org.hibernate.event: This package defines an event framework for Hibernate.
org.hibernate.event.def: This package defines a default set of event listeners that implements the default behaviors of Hibernate.
org.hibernate.exception: This package is a fork of Apache commons-lang nestable exceptions.
org.hibernate.hql: This package defines the interface between Hibernate and the HQL query parser implementation (to allow switching between the 2.x and 3.0 HQL parsers).
org.hibernate.hql.ast: An ANTLR-based parser for Hibernate Query Language.
org.hibernate.hql.ast.exec
org.hibernate.hql.classic: This package contains the Hibernate 2.x query parser which is being end-of-lifed.
org.hibernate.id: This package contains internal implementation classes for the main API interfaces.
org.hibernate.id.enhanced
org.hibernate.impl: This package contains implementations of the central Hibernate APIs, especially the Hibernate session.
org.hibernate.intercept: This package implements an interception mechanism for lazy property fetching, based on CGLIB bytecode instrumentation.
org.hibernate.jdbc: This package abstracts the mechanism for dispatching SQL statements to the database, and implements interaction with JDBC.
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.persister: A persister defines a mapping strategy for a collection or entity.
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.pretty: Classes for pretty printing things for exception and log messages.
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.cglib
org.hibernate.proxy.pojo.javassist
org.hibernate.secure: Declarative security for CRUD operations on entities.
org.hibernate.sql.ordering.antlr
org.hibernate.testing.junit.functional
org.hibernate.testing.tm: Defines a simplified JTA TransactionManager and transactional connection pool designed for use in test suite and simple usage scenarios.
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.
org.hibernate.util: Utility classes.

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` Throw when an optimistic locking conflict occurs.
`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` `SessionException` Thrown when the user calls a method of a `Session` that is in an inappropropriate 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` `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` `Transaction.begin()` Begin a new transaction.
`Transaction` `Session.beginTransaction()` Begin a unit of work and return the associated `Transaction` object.
`void` `Session.cancelQuery()` Cancel the execution of the current query.
`void` `SessionFactory.close()` Destroy this `SessionFactory` and release all resources (caches, connection pools, etc).
`Connection` `Session.close()` End the session by releasing the JDBC connection and cleaning up.
`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.
`void` `Transaction.commit()` Flush the associated `Session` and end the unit of work (unless we are in `FlushMode.MANUAL`.
`Connection` `Session.connection()` Deprecated. (scheduled for removal in 4.x). Replacement depends on need; for doing direct JDBC stuff use `Session.doWork(org.hibernate.jdbc.Work)`; for opening a 'temporary Session' use (TBD).
`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)` Join an association using the specified join-type, assigning an alias to the joined association.
`Criteria` `Criteria.createAlias(String associationPath, String alias, int 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)` 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)` 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, int joinType, Criterion withClause)` Create a new `Criteria`, "rooted" at the associated entity, assigning the given alias and using the specified join type.
`Query` `Session.createFilter(Object collection, String queryString)` Create a new instance of `Query` for the given collection and filter string.
`Query` `Session.createQuery(String queryString)` Create a new instance of `Query` for the given HQL query string.
`SQLQuery` `StatelessSession.createSQLQuery(String queryString)` Create a new instance of `SQLQuery` for the given SQL query string.
`SQLQuery` `Session.createSQLQuery(String queryString)` Create a new instance of `SQLQuery` for the given SQL query string.
`void` `Session.delete(Object object)` Remove a persistent instance from the datastore.
`void` `Session.delete(String entityName, Object object)` Remove a persistent instance from the datastore.
`Connection` `Session.disconnect()` Disconnect the `Session` from the current JDBC connection.
`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` `Session.evict(Object object)` Remove this instance from the session cache.
`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` `Session.get(Class clazz, Serializable id)` Return the persistent instance of the given entity class with the given identifier, or null if there is no such persistent instance.
`Object` `Session.get(Class clazz, Serializable id, LockMode lockMode)` Deprecated. LockMode parameter should be replaced with LockOptions
`Object` `Session.get(Class clazz, Serializable id, LockOptions lockOptions)` Return the persistent instance of the given entity class with the given identifier, or null if there is no such persistent instance.
`Object` `ScrollableResults.get(int i)` Get the `i`th object in the current row of results, without initializing any other results in the row.
`Object` `Session.get(String entityName, Serializable id)` Return the persistent instance of the given named entity with the given identifier, or null if there is no such persistent instance.
`Object` `Session.get(String entityName, Serializable id, LockMode lockMode)` Deprecated. LockMode parameter should be replaced with LockOptions
`Object` `Session.get(String entityName, Serializable id, LockOptions lockOptions)` Return the persistent instance of the given entity class with the given identifier, or null if there is no such persistent instance.
`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`
`LockMode` `Session.getCurrentLockMode(Object object)` Determine the current lock mode of the given object.
`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`
`String` `Session.getEntityName(Object object)` Return the entity name for a persistent entity
`FilterDefinition` `SessionFactory.getFilterDefinition(String filterName)` Obtain the definition of a filter by name.
`Float` `ScrollableResults.getFloat(int col)` Convenience method to read a `float`
`Serializable` `Session.getIdentifier(Object object)` Return the identifier value of the given entity as associated with this session.
`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.
`Query` `Session.getNamedQuery(String queryName)` Obtain an instance of `Query` for a named query string defined in the mapping file.
`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` `Transaction.isActive()` Is this transaction still active? Again, this only returns information in relation to the local transaction, not the actual underlying transaction.
`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.
`Object` `Session.load(Class theClass, Serializable id)` Return the persistent instance of the given entity class with the given identifier, assuming that the instance exists.
`Object` `Session.load(Class theClass, Serializable id, LockMode lockMode)` Deprecated. LockMode parameter should be replaced with LockOptions
`Object` `Session.load(Class theClass, Serializable id, LockOptions lockOptions)` Return the persistent instance of the given entity class with the given identifier, obtaining the specified lock mode, assuming the instance exists.
`void` `Session.load(Object object, Serializable id)` Read the persistent state associated with the given identifier into the given transient instance.
`Object` `Session.load(String entityName, Serializable id)` Return the persistent instance of the given entity class with the given identifier, assuming that the instance exists.
`Object` `Session.load(String entityName, Serializable id, LockMode lockMode)` Deprecated. LockMode parameter should be replaced with LockOptions
`Object` `Session.load(String entityName, Serializable id, LockOptions lockOptions)` Return the persistent instance of the given entity class with the given identifier, obtaining the specified lock mode, assuming the instance exists.
`void` `Session.LockRequest.lock(Object object)`
`void` `Session.lock(Object object, LockMode lockMode)` Deprecated. instead call buildLockRequest(LockMode).lock(object)
`void` `Session.LockRequest.lock(String entityName, Object object)`
`void` `Session.lock(String entityName, Object object, LockMode lockMode)` Deprecated. instead call buildLockRequest(LockMode).lock(entityName, object)
`Object` `Session.merge(Object object)` Copy the state of the given object onto the persistent object with the same identifier.
`Object` `Session.merge(String entityName, Object object)` Copy the state of the given object onto the persistent object with the same identifier.
`boolean` `ScrollableResults.next()` Advance to the next result
`Session` `SessionFactory.openSession()` Open a `Session`.
`Session` `SessionFactory.openSession(Interceptor interceptor)` Open a `Session`, utilizing the specified `Interceptor`.
`static ConnectionReleaseMode` `ConnectionReleaseMode.parse(String modeName)` Determine the correct ConnectionReleaseMode instance based on the given name.
`void` `Session.persist(Object object)` Make a transient instance persistent.
`void` `Session.persist(String entityName, Object object)` Make a transient instance persistent.
`boolean` `ScrollableResults.previous()` Retreat to the previous result
`void` `Session.reconnect()` Deprecated. Manual reconnection is only needed in the case of application-supplied connections, in which case the `Session.reconnect(java.sql.Connection)` for should be used.
`void` `Session.reconnect(Connection connection)` Reconnect to the given JDBC connection.
`void` `Session.refresh(Object object)` Re-read the state of the given instance from the underlying database.
`void` `Session.refresh(Object object, LockMode lockMode)` Deprecated. LockMode parameter should be replaced with LockOptions
`void` `Session.refresh(Object object, LockOptions lockOptions)` Re-read the state of the given instance from the underlying database, with the given `LockMode`.
`void` `Transaction.registerSynchronization(Synchronization synchronization)` Register a user synchronization callback for this transaction.
`void` `Session.replicate(Object object, ReplicationMode replicationMode)` Persist the state of the given detached instance, reusing the current identifier value.
`void` `Session.replicate(String entityName, Object object, ReplicationMode replicationMode)` Persist the state of the given detached instance, reusing the current identifier value.
`void` `Transaction.rollback()` Force the underlying transaction to roll back.
`Serializable` `Session.save(Object object)` Persist the given transient instance, first assigning a generated identifier.
`Serializable` `Session.save(String entityName, Object object)` Persist the given transient instance, first assigning a generated identifier.
`void` `Session.saveOrUpdate(Object object)` Either `Session.save(Object)` or `Session.update(Object)` the given instance, depending upon resolution of the unsaved-value checks (see the manual for discussion of unsaved-value checking).
`void` `Session.saveOrUpdate(String entityName, Object object)` Either `Session.save(String, Object)` or `Session.update(String, Object)` the given instance, depending upon resolution of the unsaved-value checks (see the manual for discussion of unsaved-value checking).
`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` `Session.update(Object object)` Update the persistent instance with the identifier of the given detached instance.
`void` `Session.update(String entityName, Object object)` Update the persistent instance with the identifier of the given detached instance.
`void` `Filter.validate()` Perform validation of the filter state.
`boolean` `Transaction.wasCommitted()` Check if this transaction was successfully committed.
`boolean` `Transaction.wasRolledBack()` Was this transaction rolled back or set to rollback only? This only accounts for actions initiated from this local transaction.

Uses of HibernateException in org.hibernate.action

Methods in org.hibernate.action that throw HibernateException
`void` `Executable.beforeExecutions()` Called before executing any actions.
`void` `BulkOperationCleanupAction.beforeExecutions()`
`void` `EntityInsertAction.doAfterTransactionCompletion(boolean success, SessionImplementor session)` Perform whatever processing is encapsulated here after completion of the transaction.
`void` `EntityDeleteAction.doAfterTransactionCompletion(boolean success, SessionImplementor session)`
`void` `Executable.execute()` Execute this action
`void` `EntityUpdateAction.execute()`
`void` `EntityInsertAction.execute()`
`void` `EntityIdentityInsertAction.execute()`
`void` `EntityDeleteAction.execute()`
`void` `CollectionUpdateAction.execute()`
`void` `CollectionRemoveAction.execute()`
`void` `CollectionRecreateAction.execute()`
`void` `BulkOperationCleanupAction.execute()`

Constructors in org.hibernate.action that throw HibernateException
`EntityIdentityInsertAction(Object[] state, Object instance, EntityPersister persister, SessionImplementor session, boolean isDelayed)`
`EntityInsertAction(Serializable id, Object[] state, Object instance, Object version, EntityPersister persister, 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.cache

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

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

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

Uses of HibernateException in org.hibernate.cache.entry

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

Constructors in org.hibernate.cache.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()` Create a `SessionFactory` using the properties and mappings in this configuration.
`Settings` `Configuration.buildSettings(Properties props)`
`Configuration` `Configuration.configure()` Use the mappings and properties specified in an application resource named `hibernate.cfg.xml`.
`AnnotationConfiguration` `AnnotationConfiguration.configure()` Deprecated.
`Configuration` `Configuration.configure(Document document)` Use the mappings and properties specified in the given XML document.
`AnnotationConfiguration` `AnnotationConfiguration.configure(Document document)` Deprecated.
`Configuration` `Configuration.configure(File configFile)` Use the mappings and properties specified in the given application file.
`AnnotationConfiguration` `AnnotationConfiguration.configure(File configFile)` Deprecated.
`Configuration` `Configuration.configure(String resource)` Use the mappings and properties specified in the given application resource.
`AnnotationConfiguration` `AnnotationConfiguration.configure(String resource)` Deprecated.
`Configuration` `Configuration.configure(URL url)` Use the mappings and properties specified in the given document.
`AnnotationConfiguration` `AnnotationConfiguration.configure(URL url)` 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(org.dom4j.Document doc)` Deprecated.
`protected Configuration` `Configuration.doConfigure(InputStream stream, String resourceName)` Configure this configuration's state from the contents of the given input stream.
`protected AnnotationConfiguration` `AnnotationConfiguration.doConfigure(InputStream stream, String resourceName)` Deprecated.
`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.classic

Subclasses of HibernateException in org.hibernate.classic
`class` `ValidationFailure` Thrown from `Validatable.validate()` when an invariant was violated.

Methods in org.hibernate.classic that throw HibernateException
`int` `Session.delete(String query)` Deprecated. consider using HQL delete statements
`int` `Session.delete(String query, Object[] values, Type[] types)` Deprecated. consider using HQL delete statements
`int` `Session.delete(String query, Object value, Type type)` Deprecated. consider using HQL delete statements
`Collection` `Session.filter(Object collection, String filter)` Deprecated. use `Session.createFilter(Object, String)`.`Query.list()`
`Collection` `Session.filter(Object collection, String filter, Object[] values, Type[] types)` Deprecated. use `Session.createFilter(Object, String)`.setXYZ.`Query.list()`
`Collection` `Session.filter(Object collection, String filter, Object value, Type type)` Deprecated. use `Session.createFilter(Object, String)`.setXYZ.`Query.list()`
`List` `Session.find(String query)` Deprecated. use `Session.createQuery(java.lang.String)`.`Query.list()`
`List` `Session.find(String query, Object[] values, Type[] types)` Deprecated. use `Session.createQuery(java.lang.String)`.setXYZ.`Query.list()`
`List` `Session.find(String query, Object value, Type type)` Deprecated. use `Session.createQuery(java.lang.String)`.setXYZ.`Query.list()`
`Iterator` `Session.iterate(String query)` Deprecated. use `Session.createQuery(java.lang.String)`.`Query.iterate()`
`Iterator` `Session.iterate(String query, Object[] values, Type[] types)` Deprecated. use `Session.createQuery(java.lang.String)`.setXYZ.`Query.iterate()`
`Iterator` `Session.iterate(String query, Object value, Type type)` Deprecated. use `Session.createQuery(java.lang.String)`.setXYZ.`Query.iterate()`
`void` `Session.save(Object object, Serializable id)` Deprecated. declare identifier properties for all classes
`void` `Session.save(String entityName, Object object, Serializable id)` Deprecated. declare identifier properties for all classes
`Object` `Session.saveOrUpdateCopy(Object object)` Deprecated. use `Session.merge(Object)`
`Object` `Session.saveOrUpdateCopy(Object object, Serializable id)` Deprecated. with no replacement
`Object` `Session.saveOrUpdateCopy(String entityName, Object object)` Deprecated. use `Session.merge(String, Object)`
`Object` `Session.saveOrUpdateCopy(String entityName, Object object, Serializable id)` Deprecated. with no replacement
`void` `Session.update(Object object, Serializable id)` Deprecated. declare identifier properties for all classes
`void` `Session.update(String entityName, Object object, Serializable id)` Deprecated. declare identifier properties for all classes

Uses of HibernateException in org.hibernate.collection

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

Constructors in org.hibernate.collection 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.connection

Methods in org.hibernate.connection that throw HibernateException
`void` `ProxoolConnectionProvider.close()` Release all resources held by this provider.
`void` `ConnectionProvider.close()` Release all resources held by this provider.
`void` `ProxoolConnectionProvider.configure(Properties props)` Initialize the connection provider from given properties.
`void` `C3P0ConnectionProvider.configure(Properties props)` Initialize the connection provider from given properties.
`void` `UserSuppliedConnectionProvider.configure(Properties props)`
`void` `DriverManagerConnectionProvider.configure(Properties props)`
`void` `DatasourceConnectionProvider.configure(Properties props)`
`void` `ConnectionProvider.configure(Properties props)` Initialize the connection provider from given properties.
`static ConnectionProvider` `ConnectionProviderFactory.newConnectionProvider()` Instantiate a `ConnectionProvider` using `System` properties.
`static ConnectionProvider` `ConnectionProviderFactory.newConnectionProvider(Properties properties)` Instantiate a `ConnectionProvider` using given properties.
`static ConnectionProvider` `ConnectionProviderFactory.newConnectionProvider(Properties properties, Map connectionProviderInjectionData)` Create a connection provider based on the given information.

Uses of HibernateException in org.hibernate.context

Methods in org.hibernate.context that throw HibernateException
`Session` `ThreadLocalSessionContext.currentSession()` Retrieve the current session according to the scoping defined by this implementation.
`Session` `JTASessionContext.currentSession()` Retrieve the current session according to the scoping defined by this implementation.
`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, StringBuffer buf)`
`protected void` `Example.appendPropertyCondition(String propertyName, Object propertyValue, Criteria criteria, CriteriaQuery cq, StringBuffer buf)`
`DetachedCriteria` `DetachedCriteria.createAlias(String associationPath, String alias)`
`DetachedCriteria` `DetachedCriteria.createAlias(String associationPath, String alias, int joinType)`
`DetachedCriteria` `DetachedCriteria.createAlias(String associationPath, String alias, int joinType, Criterion withClause)`
`DetachedCriteria` `DetachedCriteria.createCriteria(String associationPath)`
`DetachedCriteria` `DetachedCriteria.createCriteria(String associationPath, int joinType)`
`DetachedCriteria` `DetachedCriteria.createCriteria(String associationPath, String alias)`
`DetachedCriteria` `DetachedCriteria.createCriteria(String associationPath, String alias, int joinType)`
`DetachedCriteria` `DetachedCriteria.createCriteria(String associationPath, String alias, int 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[]` `SubqueryExpression.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)`
`TypedValue[]` `SizeExpression.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)`
`TypedValue[]` `SimpleSubqueryExpression.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)`
`TypedValue[]` `SimpleExpression.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)`
`TypedValue[]` `SQLCriterion.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)`
`TypedValue[]` `PropertyExpression.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)`
`TypedValue[]` `NullExpression.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)`
`TypedValue[]` `NotNullExpression.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)`
`TypedValue[]` `NotExpression.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)`
`TypedValue[]` `NaturalIdentifier.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)`
`TypedValue[]` `LogicalExpression.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)`
`TypedValue[]` `LikeExpression.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)`
`TypedValue[]` `Junction.getTypedValues(Criteria crit, CriteriaQuery criteriaQuery)`
`TypedValue[]` `InExpression.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)`
`TypedValue[]` `IlikeExpression.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)`
`TypedValue[]` `IdentifierEqExpression.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)`
`TypedValue[]` `Example.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)`
`TypedValue[]` `Criterion.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)` Return typed values for all parameters in the rendered SQL fragment
`TypedValue[]` `BetweenExpression.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)`
`TypedValue[]` `AbstractEmptinessExpression.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)`
`Type[]` `SQLProjection.getTypes(Criteria crit, CriteriaQuery criteriaQuery)`
`Type[]` `RowCountProjection.getTypes(Criteria criteria, CriteriaQuery criteriaQuery)`
`Type[]` `PropertyProjection.getTypes(Criteria criteria, CriteriaQuery criteriaQuery)`
`Type[]` `ProjectionList.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[]` `Distinct.getTypes(Criteria criteria, CriteriaQuery criteriaQuery)`
`Type[]` `AliasedProjection.getTypes(Criteria criteria, CriteriaQuery criteriaQuery)`
`Type[]` `AggregateProjection.getTypes(Criteria criteria, CriteriaQuery criteriaQuery)` Types returned by the rendered SQL `fragment`.
`Type[]` `SimpleProjection.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[]` `Distinct.getTypes(String alias, Criteria criteria, CriteriaQuery criteriaQuery)`
`Type[]` `AliasedProjection.getTypes(String alias, Criteria criteria, CriteriaQuery criteriaQuery)`
`Type` `CriteriaQuery.getTypeUsingProjection(Criteria criteria, String propertyPath)` Get the type of a property path
`DetachedCriteria` `DetachedCriteria.setFetchMode(String associationPath, FetchMode mode)`
`String` `SimpleProjection.toGroupSqlString(Criteria criteria, CriteriaQuery criteriaQuery)`
`String` `SQLProjection.toGroupSqlString(Criteria criteria, CriteriaQuery criteriaQuery)`
`String` `PropertyProjection.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` `Distinct.toGroupSqlString(Criteria criteria, CriteriaQuery criteriaQuery)`
`String` `AliasedProjection.toGroupSqlString(Criteria criteria, CriteriaQuery criteriaQuery)`
`String` `SubqueryExpression.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)`
`String` `SizeExpression.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)`
`String` `SimpleExpression.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)`
`String` `SQLCriterion.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)`
`String` `PropertyExpression.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)`
`String` `Order.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)` Render the SQL fragment
`String` `NullExpression.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)`
`String` `NotNullExpression.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)`
`String` `NotExpression.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)`
`String` `NaturalIdentifier.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)`
`String` `LogicalExpression.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)`
`String` `LikeExpression.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)`
`String` `Junction.toSqlString(Criteria crit, CriteriaQuery criteriaQuery)`
`String` `InExpression.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)`
`String` `IlikeExpression.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)`
`String` `IdentifierEqExpression.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)`
`String` `Example.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)`
`String` `Criterion.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)` Render the SQL fragment
`String` `BetweenExpression.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)`
`String` `AbstractEmptinessExpression.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)`
`String` `SQLProjection.toSqlString(Criteria criteria, int loc, CriteriaQuery criteriaQuery)`
`String` `RowCountProjection.toSqlString(Criteria criteria, int position, CriteriaQuery criteriaQuery)`
`String` `PropertyProjection.toSqlString(Criteria criteria, int position, CriteriaQuery criteriaQuery)`
`String` `ProjectionList.toSqlString(Criteria criteria, int loc, 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)`
`String` `Distinct.toSqlString(Criteria criteria, int position, CriteriaQuery criteriaQuery)`
`String` `AliasedProjection.toSqlString(Criteria criteria, int position, CriteriaQuery criteriaQuery)`
`String` `AggregateProjection.toSqlString(Criteria criteria, int loc, CriteriaQuery criteriaQuery)` Render the SQL fragment to be used in the `SELECT` clause.

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` typecode.
`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, int 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.resolver

Methods in org.hibernate.dialect.resolver that throw HibernateException
`static Dialect` `DialectFactory.buildDialect(Properties properties, Connection connection)` Builds an appropriate Dialect instance.

Uses of HibernateException in org.hibernate.ejb

Methods in org.hibernate.ejb with parameters of type HibernateException
`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)` 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.
`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.
`void` `HibernateEntityManagerImplementor.throwPersistenceException(HibernateException e)` Delegates to `HibernateEntityManagerImplementor.convert(org.hibernate.HibernateException, org.hibernate.LockOptions)` and then throws the given exception.
`void` `AbstractEntityManagerImpl.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
`Settings` `Ejb3Configuration.buildSettings()`
`Ejb3Configuration` `Ejb3Configuration.configure(String resource)`

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

Methods in org.hibernate.ejb.transaction that throw HibernateException
`void` `JoinableCMTTransaction.begin()`
`void` `JoinableCMTTransaction.commit()`
`Transaction` `JoinableCMTTransactionFactory.createTransaction(JDBCContext jdbcContext, TransactionFactory.Context transactionContext)`

Uses of HibernateException in org.hibernate.engine

Methods in org.hibernate.engine 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)
`CollectionEntry` `PersistenceContext.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` `PersistenceContext.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.
`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.
`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.
`abstract void` `CascadingAction.cascade(EventSource session, Object child, String entityName, Object anything, boolean isCascadeDeleteEnabled)` Cascade the action to the child object.
`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.
`void` `PersistenceContext.checkUniqueness(EntityKey key, Object object)` Attempts to check whether the given key represents an entity already loaded within the current session.
`Serializable` `TransactionHelper.doWorkInNewTransaction(SessionImplementor session)` Suspend the current transaction and perform work in a new transaction
`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
`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
`Object[]` `PersistenceContext.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.
`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
`Object[]` `StatefulPersistenceContext.getNaturalIdSnapshot(Serializable id, EntityPersister persister)`
`Object[]` `PersistenceContext.getNaturalIdSnapshot(Serializable id, EntityPersister persister)` Get the values of the natural id fields as known to the underlying database, or null if the entity has no natural id or there is no corresponding row.
`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)
`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)
`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.
`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.
`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` `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.
`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.
`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
`Session` `SessionFactoryImplementor.openSession(Connection connection, boolean flushBeforeCompletionEnabled, boolean autoCloseSessionEnabled, ConnectionReleaseMode connectionReleaseMode)` Open a session conforming to the given parameters.
`Session` `SessionFactoryImplementor.openTemporarySession()` Get a nontransactional "current" session for Hibernate EntityManager
`void` `CollectionEntry.postFlush(PersistentCollection collection)` Called after a successful flush
`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.
`void` `CollectionEntry.postInitialize(PersistentCollection collection)`
`void` `CollectionEntry.preFlush(PersistentCollection collection)`
`void` `ActionQueue.prepareActions()` Prepares the internal action queues for execution.
`static void` `Collections.processReachableCollection(PersistentCollection collection, CollectionType type, Object entity, SessionImplementor session)` Initialize the role of the collection.
`static void` `Collections.processUnreachableCollection(PersistentCollection coll, SessionImplementor session)` record the fact that this collection was dereferenced
`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` `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` `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` `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` `StatefulPersistenceContext.unproxy(Object maybeProxy)` Get the entity instance underlying the given proxy, throwing an exception if the proxy is uninitialized.
`Object` `PersistenceContext.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.
`Object` `PersistenceContext.unproxyAndReassociate(Object maybeProxy)` Possibly unproxy the given reference and reassociate it with the current session.

Uses of HibernateException in org.hibernate.engine.query

Methods in org.hibernate.engine.query 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.transaction

Subclasses of HibernateException in org.hibernate.engine.transaction
`class` `NullSynchronizationException` TODO : javadoc

Methods in org.hibernate.engine.transaction that throw HibernateException
`void` `Isolater.JtaDelegate.delegateWork(IsolatedWork work, boolean transacted)`
`void` `Isolater.JdbcDelegate.delegateWork(IsolatedWork work, boolean transacted)`
`static void` `Isolater.doIsolatedWork(IsolatedWork work, SessionImplementor session)` Ensures that all processing actually performed by the given work will occur on a seperate transaction.
`static void` `Isolater.doNonTransactedWork(IsolatedWork work, SessionImplementor session)` Ensures that all processing actually performed by the given work will occur outside of a transaction.
`void` `IsolatedWork.doWork(Connection connection)` Perform the actual work to be done.

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, Object owner)`
`void` `RevisionTypeType.nullSafeSet(PreparedStatement preparedStatement, Object value, int index)`
`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.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

Methods in org.hibernate.event 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` `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 refesh an entity instance
`void` `EventSource.saveOrUpdateCopy(String entityName, Object object, Map copiedAlready)` Cascade copy an entity instance

Uses of HibernateException in org.hibernate.event.def

Methods in org.hibernate.event.def 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, EntityMode entityMode, 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` `DefaultPersistEventListener.entityIsTransient(PersistEvent event, Map createCache)` Handle the given create 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)`
`protected void` `AbstractFlushingEventListener.performExecutions(EventSource session)` Execute all SQL and second-level cache updates, in a special order so that foreign-key constraints cannot be violated: Inserts, in the order they were performed Updates Deletion of collection elements Insertion of collection elements Deletes, in the order they were performed
`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.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).

Methods in org.hibernate.exception 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

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

Methods in org.hibernate.hql 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.hql.ast

Subclasses of HibernateException in org.hibernate.hql.ast
`class` `InvalidWithClauseException`
`class` `QuerySyntaxException` Exception thrown when there is a syntax error in the HQL.

Methods in org.hibernate.hql.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.ast.exec

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

Uses of HibernateException in org.hibernate.hql.classic

Methods in org.hibernate.hql.classic that throw HibernateException
`int` `QueryTranslatorImpl.executeUpdate(QueryParameters queryParameters, SessionImplementor session)`
`protected Object` `QueryTranslatorImpl.getResultColumnOrRow(Object[] row, ResultTransformer transformer, 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.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` `UUIDGenerator.generate(SessionImplementor session, Object object)`
`Serializable` `MultipleHiLoPerTableGenerator.generate(SessionImplementor session, Object obj)`
`Serializable` `IncrementGenerator.generate(SessionImplementor session, Object object)`
`Serializable` `IdentifierGenerator.generate(SessionImplementor session, Object object)` Generate a new identifier.
`Serializable` `GUIDGenerator.generate(SessionImplementor session, Object obj)`
`Serializable` `CompositeNestedGeneratedValueGenerator.generate(SessionImplementor session, Object object)`
`Serializable` `Assigned.generate(SessionImplementor session, Object obj)`
`static Serializable` `IdentifierGeneratorHelper.getGeneratedIdentity(ResultSet rs, String identifierColumnName, Type type)` Get the generated identifier when using identity columns
`InsertGeneratedIdentifierDelegate` `SequenceIdentityGenerator.getInsertGeneratedIdentifierDelegate(PostInsertIdentityPersister persister, Dialect dialect, boolean isGetGeneratedKeysEnabled)`
`InsertGeneratedIdentifierDelegate` `SelectGenerator.getInsertGeneratedIdentifierDelegate(PostInsertIdentityPersister persister, Dialect dialect, boolean isGetGeneratedKeysEnabled)`
`InsertGeneratedIdentifierDelegate` `PostInsertIdentifierGenerator.getInsertGeneratedIdentifierDelegate(PostInsertIdentityPersister persister, Dialect dialect, boolean isGetGeneratedKeysEnabled)`
`InsertGeneratedIdentifierDelegate` `IdentityGenerator.getInsertGeneratedIdentifierDelegate(PostInsertIdentityPersister persister, Dialect dialect, boolean isGetGeneratedKeysEnabled)`
`String[]` `TableGenerator.sqlCreateStrings(Dialect dialect)`
`String[]` `SequenceGenerator.sqlCreateStrings(Dialect dialect)`
`String[]` `PersistentIdentifierGenerator.sqlCreateStrings(Dialect dialect)` The SQL required to create the underlying database objects.
`String[]` `MultipleHiLoPerTableGenerator.sqlCreateStrings(Dialect dialect)`
`String[]` `SequenceGenerator.sqlDropStrings(Dialect dialect)`
`String[]` `PersistentIdentifierGenerator.sqlDropStrings(Dialect dialect)` The SQL required to remove the underlying database objects.
`String[]` `MultipleHiLoPerTableGenerator.sqlDropStrings(Dialect dialect)`

Uses of HibernateException in org.hibernate.id.enhanced

Methods in org.hibernate.id.enhanced that throw HibernateException
`Serializable` `SequenceStyleGenerator.generate(SessionImplementor session, Object object)` Generate a new identifier.
`String[]` `TableStructure.sqlCreateStrings(Dialect dialect)` Commands needed to create the underlying structures.
`String[]` `TableGenerator.sqlCreateStrings(Dialect dialect)` The SQL required to create the underlying database objects.
`String[]` `SequenceStyleGenerator.sqlCreateStrings(Dialect dialect)` The SQL required to create the underlying database objects.
`String[]` `SequenceStructure.sqlCreateStrings(Dialect dialect)` Commands needed to create the underlying structures.
`String[]` `TableStructure.sqlDropStrings(Dialect dialect)` Commands needed to drop the underlying structures.
`String[]` `TableGenerator.sqlDropStrings(Dialect dialect)` The SQL required to remove the underlying database objects.
`String[]` `SequenceStyleGenerator.sqlDropStrings(Dialect dialect)` The SQL required to remove the underlying database objects.
`String[]` `SequenceStructure.sqlDropStrings(Dialect dialect)` Commands needed to drop the underlying structures.

Uses of HibernateException in org.hibernate.impl

Methods in org.hibernate.impl that throw HibernateException
`void` `ScrollableResultsImpl.afterLast()`
`void` `FetchingScrollableResultsImpl.afterLast()` Go to a location just after the last result
`void` `SessionImpl.applyNonFlushedChanges(NonFlushedChanges nonFlushedChanges)` Apply non-flushed changes from a different session to this session.
`protected boolean` `StatelessSessionImpl.autoFlushIfRequired(Set querySpaces)`
`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` `ScrollableResultsImpl.beforeFirst()`
`void` `FetchingScrollableResultsImpl.beforeFirst()` Go to a location just before first result (this is the initial location)
`Transaction` `StatelessSessionImpl.beginTransaction()`
`Transaction` `SessionImpl.beginTransaction()`
`void` `SessionImpl.cancelQuery()`
`Connection` `SessionImpl.close()`
`void` `SessionFactoryImpl.close()` Closes the session factory, releasing all held resources.
`void` `AbstractScrollableResults.close()`
`Connection` `SessionImpl.connection()`
`Criteria` `CriteriaImpl.Subcriteria.createAlias(String associationPath, String alias, int joinType)`
`Criteria` `CriteriaImpl.Subcriteria.createAlias(String associationPath, String alias, int joinType, Criterion withClause)`
`Criteria` `CriteriaImpl.Subcriteria.createCriteria(String associationPath, int joinType)`
`Criteria` `CriteriaImpl.Subcriteria.createCriteria(String associationPath, String alias, int joinType)`
`Criteria` `CriteriaImpl.Subcriteria.createCriteria(String associationPath, String alias, int joinType, Criterion withClause)`
`void` `SessionImpl.delete(Object object)` Delete a persistent object
`int` `SessionImpl.delete(String query)`
`void` `SessionImpl.delete(String entityName, Object object)` Delete a persistent object (by explicit entity name)
`int` `SessionImpl.delete(String query, Object[] values, Type[] types)`
`void` `SessionImpl.delete(String entityName, Object object, boolean isCascadeDeleteEnabled, Set transientEntities)` Delete a persistent object
`int` `SessionImpl.delete(String query, Object value, Type type)`
`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()`
`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` `StatelessSessionImpl.executeNativeUpdate(NativeSQLQuerySpecification nativeSQLQuerySpecification, QueryParameters queryParameters)`
`int` `SessionImpl.executeNativeUpdate(NativeSQLQuerySpecification nativeQuerySpecification, QueryParameters queryParameters)`
`int` `SQLQueryImpl.executeUpdate()`
`int` `QueryImpl.executeUpdate()`
`int` `StatelessSessionImpl.executeUpdate(String query, QueryParameters queryParameters)`
`int` `SessionImpl.executeUpdate(String query, QueryParameters queryParameters)`
`Collection` `SessionImpl.filter(Object collection, String filter)`
`Collection` `SessionImpl.filter(Object collection, String filter, Object[] values, Type[] types)`
`Collection` `SessionImpl.filter(Object collection, String filter, Object value, Type type)`
`List` `SessionImpl.find(String query)` Retrieve a list of persistent objects using a hibernate query
`List` `SessionImpl.find(String query, Object[] values, Type[] types)`
`List` `SessionImpl.find(String query, Object value, Type type)`
`boolean` `ScrollableResultsImpl.first()`
`boolean` `FetchingScrollableResultsImpl.first()` Go to the first result
`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` `StatelessSessionImpl.getEntityUsingInterceptor(EntityKey key)`
`Object` `SessionImpl.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` `ScrollableResultsImpl.getRowNumber()`
`int` `FetchingScrollableResultsImpl.getRowNumber()` Get the current location in the result set.
`Short` `AbstractScrollableResults.getShort(int col)`
`String` `AbstractScrollableResults.getString(int col)`
`String` `AbstractScrollableResults.getText(int col)`
`TimeZone` `AbstractScrollableResults.getTimeZone(int col)`
`Transaction` `StatelessSessionImpl.getTransaction()`
`Transaction` `SessionImpl.getTransaction()`
`String` `StatelessSessionImpl.guessEntityName(Object entity)`
`String` `SessionImpl.guessEntityName(Object object)`
`Object` `StatelessSessionImpl.immediateLoad(String entityName, Serializable id)`
`Object` `SessionImpl.immediateLoad(String entityName, Serializable id)` Load the data for the object with the specified id into a newly created object.
`void` `StatelessSessionImpl.initializeCollection(PersistentCollection collection, boolean writing)`
`void` `SessionImpl.initializeCollection(PersistentCollection collection, boolean writing)`
`Object` `SessionImpl.instantiate(EntityPersister persister, Serializable id)` give the interceptor an opportunity to override the default instantiation
`Object` `StatelessSessionImpl.instantiate(String entityName, Serializable id)`
`Object` `SessionImpl.instantiate(String entityName, Serializable id)`
`Object` `StatelessSessionImpl.internalLoad(String entityName, Serializable id, boolean eager, boolean nullable)`
`Object` `SessionImpl.internalLoad(String entityName, Serializable id, boolean eager, boolean nullable)`
`boolean` `SessionImpl.isDirty()`
`boolean` `ScrollableResultsImpl.isFirst()`
`boolean` `FetchingScrollableResultsImpl.isFirst()` Is this the first result?
`boolean` `ScrollableResultsImpl.isLast()`
`boolean` `FetchingScrollableResultsImpl.isLast()` Is this the last result?
`Iterator` `SQLQueryImpl.iterate()`
`Iterator` `QueryImpl.iterate()`
`Iterator` `CollectionFilterImpl.iterate()`
`Iterator` `SessionImpl.iterate(String query)`
`Iterator` `SessionImpl.iterate(String query, Object[] values, Type[] types)`
`Iterator` `SessionImpl.iterate(String query, Object value, Type type)`
`Iterator` `StatelessSessionImpl.iterate(String query, QueryParameters queryParameters)`
`Iterator` `SessionImpl.iterate(String query, QueryParameters queryParameters)`
`Iterator` `StatelessSessionImpl.iterateFilter(Object collection, String filter, QueryParameters queryParameters)`
`Iterator` `SessionImpl.iterateFilter(Object collection, String filter, QueryParameters queryParameters)`
`boolean` `ScrollableResultsImpl.last()`
`boolean` `FetchingScrollableResultsImpl.last()` Go to the last result
`List` `SQLQueryImpl.list()`
`List` `QueryImpl.list()`
`List` `CriteriaImpl.list()`
`List` `CriteriaImpl.Subcriteria.list()`
`List` `CollectionFilterImpl.list()`
`List` `StatelessSessionImpl.list(CriteriaImpl criteria)`
`List` `SessionImpl.list(CriteriaImpl criteria)`
`List` `AbstractSessionImpl.list(NativeSQLQuerySpecification spec, QueryParameters queryParameters)`
`List` `StatelessSessionImpl.list(String query, QueryParameters queryParameters)`
`List` `SessionImpl.list(String query, QueryParameters queryParameters)`
`List` `StatelessSessionImpl.listCustomQuery(CustomQuery customQuery, QueryParameters queryParameters)`
`List` `SessionImpl.listCustomQuery(CustomQuery customQuery, QueryParameters queryParameters)`
`List` `StatelessSessionImpl.listFilter(Object collection, String filter, QueryParameters queryParameters)`
`List` `SessionImpl.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` `ScrollableResultsImpl.next()`
`Object` `IteratorImpl.next()`
`boolean` `FetchingScrollableResultsImpl.next()` Advance to the next result
`Session` `SessionFactoryImpl.openSession()`
`Session` `SessionFactoryImpl.openSession(Connection connection, boolean flushBeforeCompletionEnabled, boolean autoCloseSessionEnabled, ConnectionReleaseMode connectionReleaseMode)`
`Session` `SessionFactoryImpl.openSession(Interceptor sessionLocalInterceptor)`
`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` `ScrollableResultsImpl.previous()`
`boolean` `FetchingScrollableResultsImpl.previous()` Retreat to the previous result
`void` `SessionImpl.reconnect()`
`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.replicate(Object obj, ReplicationMode replicationMode)`
`void` `SessionImpl.replicate(String entityName, Object obj, ReplicationMode replicationMode)`
`Serializable` `SessionImpl.save(Object obj)`
`void` `SessionImpl.save(Object obj, Serializable id)`
`Serializable` `SessionImpl.save(String entityName, Object object)`
`void` `SessionImpl.save(String entityName, Object object, Serializable id)`
`void` `SessionImpl.saveOrUpdate(Object object)`
`void` `SessionImpl.saveOrUpdate(String entityName, Object obj)`
`Object` `SessionImpl.saveOrUpdateCopy(Object object)`
`Object` `SessionImpl.saveOrUpdateCopy(Object object, Serializable id)`
`Object` `SessionImpl.saveOrUpdateCopy(String entityName, Object object)`
`void` `SessionImpl.saveOrUpdateCopy(String entityName, Object object, Map copiedAlready)`
`Object` `SessionImpl.saveOrUpdateCopy(String entityName, Object object, Serializable id)`
`ScrollableResults` `SQLQueryImpl.scroll()`
`ScrollableResults` `QueryImpl.scroll()`
`ScrollableResults` `CriteriaImpl.Subcriteria.scroll()`
`ScrollableResults` `CollectionFilterImpl.scroll()`
`boolean` `ScrollableResultsImpl.scroll(int i)`
`boolean` `FetchingScrollableResultsImpl.scroll(int positions)` Scroll an arbitrary number of locations
`ScrollableResults` `AbstractSessionImpl.scroll(NativeSQLQuerySpecification spec, QueryParameters queryParameters)`
`ScrollableResults` `SQLQueryImpl.scroll(ScrollMode scrollMode)`
`ScrollableResults` `QueryImpl.scroll(ScrollMode scrollMode)`
`ScrollableResults` `CriteriaImpl.Subcriteria.scroll(ScrollMode scrollMode)`
`ScrollableResults` `StatelessSessionImpl.scroll(String query, QueryParameters queryParameters)`
`ScrollableResults` `SessionImpl.scroll(String query, QueryParameters queryParameters)`
`ScrollableResults` `StatelessSessionImpl.scrollCustomQuery(CustomQuery customQuery, QueryParameters queryParameters)`
`ScrollableResults` `SessionImpl.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` `ScrollableResultsImpl.setRowNumber(int rowNumber)`
`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`).
`Object` `CriteriaImpl.uniqueResult()`
`Object` `CriteriaImpl.Subcriteria.uniqueResult()`
`Object` `AbstractQueryImpl.uniqueResult()`
`void` `SessionImpl.update(Object obj)`
`void` `SessionImpl.update(Object obj, Serializable id)`
`void` `SessionImpl.update(String entityName, Object object)`
`void` `SessionImpl.update(String entityName, Object object, Serializable id)`
`void` `FilterImpl.validate()` Perform validation of the filter state.
`protected void` `AbstractQueryImpl.verifyParameters(boolean reserveFirstParameter)` Perform parameter validation.

Constructors in org.hibernate.impl that throw HibernateException
`IteratorImpl(ResultSet rs, PreparedStatement ps, EventSource sess, boolean readOnly, Type[] types, String[][] columnNames, HolderInstantiator holderInstantiator)`
`SessionFactoryImpl(Configuration cfg, Mapping mapping, Settings settings, EventListeners listeners, SessionFactoryObserver observer)`

Uses of HibernateException in org.hibernate.intercept

Methods in org.hibernate.intercept that throw HibernateException
`Object` `LazyPropertyInitializer.initializeLazyProperty(String fieldName, Object entity, SessionImplementor session)` Initialize the property, and return its new value

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
`void` `NonBatchingBatcher.addToBatch(Expectation expectation)`
`void` `BatchingBatcher.addToBatch(Expectation expectation)`
`void` `Batcher.addToBatch(Expectation expectation)` Add an insert / delete / update to the current batch (might be called multiple times for single `prepareBatchStatement()`)
`void` `Batcher.cancelLastQuery()` Cancel the current query statement
`void` `AbstractBatcher.cancelLastQuery()`
`void` `Batcher.closeConnection(Connection conn)` Deprecated. Obtain connections from `ConnectionProvider` instead
`void` `AbstractBatcher.closeConnection(Connection conn)`
`Connection` `JDBCContext.connection()`
`protected void` `NonBatchingBatcher.doExecuteBatch(PreparedStatement ps)`
`protected void` `BatchingBatcher.doExecuteBatch(PreparedStatement ps)`
`protected abstract void` `AbstractBatcher.doExecuteBatch(PreparedStatement ps)`
`void` `Batcher.executeBatch()` Execute the batch
`void` `AbstractBatcher.executeBatch()`
`Connection` `ConnectionManager.getConnection()` Retrieves the connection currently managed by this ConnectionManager.
`Transaction` `JDBCContext.getTransaction()`
`Connection` `Batcher.openConnection()` Deprecated. Obtain connections from `ConnectionProvider` instead
`Connection` `AbstractBatcher.openConnection()`
`int` `Expectations.BasicExpectation.prepare(PreparedStatement statement)`
`int` `Expectations.BasicParamExpectation.prepare(PreparedStatement statement)`
`int` `Expectation.prepare(PreparedStatement statement)` Perform any special statement preparation.
`CallableStatement` `Batcher.prepareBatchCallableStatement(String sql)` Get a batchable callable statement to use for inserting / deleting / updating (might be called many times before a single call to `executeBatch()`).
`CallableStatement` `AbstractBatcher.prepareBatchCallableStatement(String sql)`
`PreparedStatement` `Batcher.prepareBatchStatement(String sql)` Get a batchable prepared statement to use for inserting / deleting / updating (might be called many times before a single call to `executeBatch()`).
`PreparedStatement` `AbstractBatcher.prepareBatchStatement(String sql)`
`CallableStatement` `Batcher.prepareCallableQueryStatement(String sql, boolean scrollable, ScrollMode scrollMode)` Get a prepared statement for use in loading / querying.
`CallableStatement` `AbstractBatcher.prepareCallableQueryStatement(String sql, boolean scrollable, ScrollMode scrollMode)`
`CallableStatement` `Batcher.prepareCallableStatement(String sql)` Get a non-batchable callable statement to use for inserting / deleting / updating.
`CallableStatement` `AbstractBatcher.prepareCallableStatement(String sql)`
`PreparedStatement` `Batcher.prepareQueryStatement(String sql, boolean scrollable, ScrollMode scrollMode)` Get a prepared statement for use in loading / querying.
`PreparedStatement` `AbstractBatcher.prepareQueryStatement(String sql, boolean scrollable, ScrollMode scrollMode)`
`PreparedStatement` `Batcher.prepareSelectStatement(String sql)` Get a non-batchable prepared statement to use for selecting.
`PreparedStatement` `AbstractBatcher.prepareSelectStatement(String sql)`
`PreparedStatement` `Batcher.prepareStatement(String sql)` Get a non-batchable prepared statement to use for inserting / deleting / updating.
`PreparedStatement` `AbstractBatcher.prepareStatement(String sql)`
`PreparedStatement` `Batcher.prepareStatement(String sql, boolean useGetGeneratedKeys)` Get a non-batchable prepared statement to use for inserting / deleting / updating, using JDBC3 getGeneratedKeys (`Connection.prepareStatement(String, int)`).
`PreparedStatement` `AbstractBatcher.prepareStatement(String sql, boolean getGeneratedKeys)`
`PreparedStatement` `Batcher.prepareStatement(String sql, String[] columnNames)` Get a non-batchable prepared statement to use for inserting / deleting / updating.
`PreparedStatement` `AbstractBatcher.prepareStatement(String sql, String[] columnNames)`
`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()`
`void` `HibernateServiceMBean.createSchema()` Export the `CREATE` DDL to the database
`void` `HibernateServiceMBean.dropSchema()` Export the `DROP` DDL to the database
`void` `SessionFactoryStub.evict(Class persistentClass)`
`void` `SessionFactoryStub.evict(Class persistentClass, Serializable id)`
`void` `SessionFactoryStub.evictCollection(String roleName)`
`void` `SessionFactoryStub.evictCollection(String roleName, Serializable id)`
`void` `SessionFactoryStub.evictEntity(String entityName)`
`void` `SessionFactoryStub.evictEntity(String entityName, Serializable id)`
`void` `SessionFactoryStub.evictQueries()`
`void` `SessionFactoryStub.evictQueries(String cacheRegion)`
`Map<String,ClassMetadata>` `SessionFactoryStub.getAllClassMetadata()`
`Map` `SessionFactoryStub.getAllCollectionMetadata()`
`ClassMetadata` `SessionFactoryStub.getClassMetadata(Class persistentClass)`
`ClassMetadata` `SessionFactoryStub.getClassMetadata(String entityName)`
`CollectionMetadata` `SessionFactoryStub.getCollectionMetadata(String roleName)`
`FilterDefinition` `SessionFactoryStub.getFilterDefinition(String filterName)`
`Session` `SessionFactoryStub.openSession()`
`Session` `SessionFactoryStub.openSession(Interceptor interceptor)`
`void` `HibernateServiceMBean.start()` Create the `SessionFactory` and bind to the jndi name on startup
`void` `HibernateService.start()`

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 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` `SubselectOneToManyLoader.initialize(Serializable id, SessionImplementor session)`
`void` `SubselectCollectionLoader.initialize(Serializable id, SessionImplementor session)`
`void` `CollectionLoader.initialize(Serializable id, SessionImplementor session)`
`void` `CollectionInitializer.initialize(Serializable id, SessionImplementor session)` Initialize the given collection
`void` `BatchingCollectionInitializer.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)`
`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

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.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)`
`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)`
`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, EntityMode entityMode)` 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, EntityMode entityMode)` Get the value of a particular (named) property
`Object[]` `ClassMetadata.getPropertyValues(Object entity, EntityMode entityMode)` 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, EntityMode entityMode)` Get the version number (or timestamp) from the object's version property (or return null if not versioned)
`Object` `ClassMetadata.instantiate(Serializable id, EntityMode entityMode)` Deprecated. Use `ClassMetadata.instantiate(Serializable, SessionImplementor)` instead
`void` `ClassMetadata.setIdentifier(Object entity, Serializable id, EntityMode entityMode)` Deprecated. Use `ClassMetadata.setIdentifier(Object, Serializable, SessionImplementor)` instead.
`void` `ClassMetadata.setPropertyValue(Object object, String propertyName, Object value, EntityMode entityMode)` Set the value of a particular (named) property
`void` `ClassMetadata.setPropertyValues(Object object, Object[] values, EntityMode entityMode)` Set the given values to the mapped properties of the given object

Uses of HibernateException in org.hibernate.persister

Methods in org.hibernate.persister that throw HibernateException
`static EntityPersister` `PersisterFactory.createClassPersister(PersistentClass model, EntityRegionAccessStrategy cacheAccessStrategy, SessionFactoryImplementor factory, Mapping cfg)`
`static CollectionPersister` `PersisterFactory.createCollectionPersister(Configuration cfg, Collection model, CollectionRegionAccessStrategy cacheAccessStrategy, SessionFactoryImplementor factory)`

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` `OneToManyPersister.doUpdateRows(Serializable id, PersistentCollection collection, SessionImplementor session)`
`protected int` `BasicCollectionPersister.doUpdateRows(Serializable id, PersistentCollection collection, SessionImplementor session)`
`protected abstract int` `AbstractCollectionPersister.doUpdateRows(Serializable key, PersistentCollection collection, SessionImplementor session)`
`void` `NamedQueryCollectionInitializer.initialize(Serializable key, 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` `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` `EntityPersister.createProxy(Serializable id, SessionImplementor session)` Create a new proxy instance
`Object` `AbstractEntityPersister.createProxy(Serializable id, SessionImplementor session)`
`Object` `DiscriminatorType.deepCopy(Object value, EntityMode entityMode, 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` `EntityPersister.delete(Serializable id, Object version, Object object, SessionImplementor session)` Delete a persistent instance
`void` `AbstractEntityPersister.delete(Serializable id, Object version, Object object, SessionImplementor session)` Delete an object
`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` `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.getCurrentVersion(Serializable id, SessionImplementor session)` Retrieve the version number
`Object[]` `EntityPersister.getDatabaseSnapshot(Serializable id, SessionImplementor session)` Get the current database state of the object, in a "hydrated" form, without resolving identifiers
`Object[]` `AbstractEntityPersister.getDatabaseSnapshot(Serializable id, SessionImplementor session)`
`Serializable` `EntityPersister.getIdentifier(Object object, EntityMode entityMode)` Deprecated. Use `EntityPersister.getIdentifier(Object,SessionImplementor)` instead
`Serializable` `AbstractEntityPersister.getIdentifier(Object object, EntityMode entityMode)`
`IdentifierGenerator` `AbstractEntityPersister.getIdentifierGenerator()`
`Object[]` `AbstractEntityPersister.getNaturalIdentifierSnapshot(Serializable id, SessionImplementor session)`
`Object` `EntityPersister.getPropertyValue(Object object, int i, EntityMode entityMode)` Get the value of a particular property
`Object` `AbstractEntityPersister.getPropertyValue(Object object, int i, EntityMode entityMode)`
`Object` `EntityPersister.getPropertyValue(Object object, String propertyName, EntityMode entityMode)` Get the value of a particular property
`Object` `AbstractEntityPersister.getPropertyValue(Object object, String propertyName, EntityMode entityMode)`
`Object[]` `EntityPersister.getPropertyValues(Object object, EntityMode entityMode)` Return the (loaded) values of the mapped properties of the object (not including backrefs)
`Object[]` `AbstractEntityPersister.getPropertyValues(Object object, EntityMode entityMode)`
`Object[]` `EntityPersister.getPropertyValuesToInsert(Object object, Map mergeMap, SessionImplementor session)` Return the values of the insertable properties of the object (including backrefs)
`Object[]` `AbstractEntityPersister.getPropertyValuesToInsert(Object object, Map mergeMap, SessionImplementor session)`
`Object` `EntityPersister.getVersion(Object object, EntityMode entityMode)` Get the version number (or timestamp) from the object's version property (or return null if not versioned)
`Object` `AbstractEntityPersister.getVersion(Object object, EntityMode entityMode)`
`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` `EntityPersister.insert(Object[] fields, Object object, SessionImplementor session)` Persist an instance, using a natively generated identifier (optional operation)
`Serializable` `AbstractEntityPersister.insert(Object[] fields, Object object, SessionImplementor session)`
`protected void` `AbstractEntityPersister.insert(Serializable id, Object[] fields, boolean[] notNull, int j, String sql, Object object, SessionImplementor session)` Perform an SQL INSERT.
`void` `EntityPersister.insert(Serializable id, Object[] fields, Object object, SessionImplementor session)` Persist an instance
`void` `AbstractEntityPersister.insert(Serializable id, Object[] fields, Object object, SessionImplementor session)`
`Object` `EntityPersister.instantiate(Serializable id, EntityMode entityMode)` Deprecated. Use `EntityPersister.instantiate(Serializable, SessionImplementor)` instead
`Object` `AbstractEntityPersister.instantiate(Serializable id, EntityMode entityMode)` Create a class instance initialized with the given identifier
`Object` `AbstractEntityPersister.instantiate(Serializable id, SessionImplementor session)` Create a class instance initialized with the given identifier
`boolean` `DiscriminatorType.isDirty(Object old, Object current, boolean[] checkable, SessionImplementor session)`
`Boolean` `EntityPersister.isTransient(Object object, SessionImplementor session)` Is this a new transient instance?
`Boolean` `AbstractEntityPersister.isTransient(Object entity, SessionImplementor session)`
`Object` `EntityPersister.load(Serializable id, Object optionalObject, LockMode lockMode, SessionImplementor session)` Load an instance of the persistent class.
`Object` `EntityPersister.load(Serializable id, Object optionalObject, LockOptions lockOptions, 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` `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` `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, LockMode lockMode, SessionImplementor session)`
`void` `EntityPersister.lock(Serializable id, Object version, Object object, LockOptions lockOptions, SessionImplementor session)` Do a version check (optional operation)
`void` `AbstractEntityPersister.lock(Serializable id, Object version, Object object, LockOptions lockOptions, SessionImplementor session)`
`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` `EntityPersister.setIdentifier(Object entity, Serializable id, EntityMode entityMode)` Deprecated. Use `EntityPersister.setIdentifier(Object, Serializable, SessionImplementor)` instead.
`void` `AbstractEntityPersister.setIdentifier(Object entity, Serializable id, EntityMode entityMode)` Inject the identifier value into the given entity.
`void` `EntityPersister.setPropertyValue(Object object, int i, Object value, EntityMode entityMode)` Set the value of a particular property
`void` `AbstractEntityPersister.setPropertyValue(Object object, int i, Object value, EntityMode entityMode)`
`void` `AbstractEntityPersister.setPropertyValue(Object object, String propertyName, Object value, EntityMode entityMode)`
`void` `EntityPersister.setPropertyValues(Object object, Object[] values, EntityMode entityMode)` Set the given values to the mapped properties of the given object
`void` `AbstractEntityPersister.setPropertyValues(Object object, Object[] values, EntityMode entityMode)`
`void` `DiscriminatorType.setToXMLNode(org.dom4j.Node node, Object value, SessionFactoryImplementor factory)`
`String` `DiscriminatorType.toLoggableString(Object value, SessionFactoryImplementor factory)`
`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
`void` `AbstractEntityPersister.update(Serializable id, Object[] fields, int[] dirtyFields, boolean hasDirtyCollection, Object[] oldFields, Object oldVersion, Object object, Object rowId, SessionImplementor session)` Update an object
`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(PersistentClass persistentClass, EntityRegionAccessStrategy cacheAccessStrategy, SessionFactoryImplementor factory)`
`JoinedSubclassEntityPersister(PersistentClass persistentClass, EntityRegionAccessStrategy cacheAccessStrategy, SessionFactoryImplementor factory, Mapping mapping)`
`SingleTableEntityPersister(PersistentClass persistentClass, EntityRegionAccessStrategy cacheAccessStrategy, SessionFactoryImplementor factory, Mapping mapping)`
`UnionSubclassEntityPersister(PersistentClass persistentClass, EntityRegionAccessStrategy cacheAccessStrategy, SessionFactoryImplementor factory, Mapping mapping)`

Uses of HibernateException in org.hibernate.pretty

Methods in org.hibernate.pretty that throw HibernateException
`void` `Printer.toString(Iterator iter, EntityMode entityMode)`
`String` `Printer.toString(Map namedTypedValues)`
`String` `Printer.toString(Object entity, EntityMode entityMode)`
`String` `Printer.toString(Type[] types, Object[] values)`

Uses of HibernateException in org.hibernate.property

Methods in org.hibernate.property that throw HibernateException
`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` `EmbeddedPropertyAccessor.EmbeddedGetter.get(Object target)` Get the property value from the given instance .
`Object` `Dom4jAccessor.TextGetter.get(Object owner)` Get the property value from the given instance .
`Object` `Dom4jAccessor.AttributeGetter.get(Object owner)` Get the property value from the given instance .
`Object` `Dom4jAccessor.ElementGetter.get(Object owner)` Get the property value from the given instance .
`Object` `Dom4jAccessor.ElementAttributeGetter.get(Object owner)` Get the property value from the given instance .
`Object` `DirectPropertyAccessor.DirectGetter.get(Object target)` Get the property value from the given instance .
`Object` `BasicPropertyAccessor.BasicGetter.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.
`Object` `Dom4jAccessor.Dom4jGetter.getForInsert(Object owner, Map mergeMap, SessionImplementor session)`
`void` `Setter.set(Object target, Object value, SessionFactoryImplementor factory)` Set the property value from the given instance
`void` `MapAccessor.MapSetter.set(Object target, Object value, SessionFactoryImplementor factory)` Set the property value from the given instance
`void` `Dom4jAccessor.TextSetter.set(Object target, Object value, SessionFactoryImplementor factory)` Set the property value from the given instance
`void` `Dom4jAccessor.AttributeSetter.set(Object target, Object value, SessionFactoryImplementor factory)` Set the property value from the given instance
`void` `Dom4jAccessor.ElementSetter.set(Object target, Object value, SessionFactoryImplementor factory)` Set the property value from the given instance
`void` `Dom4jAccessor.ElementAttributeSetter.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
`void` `BasicPropertyAccessor.BasicSetter.set(Object target, Object value, SessionFactoryImplementor factory)`

Uses of HibernateException in org.hibernate.proxy

Methods in org.hibernate.proxy that throw HibernateException
`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.
`Object` `AbstractLazyInitializer.getImplementation(SessionImplementor s)` Return the underlying persistent object in the given `Session`, or null, do not initialize the proxy
`HibernateProxy` `ProxyFactory.getProxy(Serializable id, SessionImplementor session)` Create a new proxy instance
`void` `LazyInitializer.initialize()` Initialize the proxy, fetching the target entity if necessary.
`void` `AbstractLazyInitializer.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` `LazyInitializer.setSession(SessionImplementor session)` Associate the proxy with the given session.
`void` `AbstractLazyInitializer.setSession(SessionImplementor s)` 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.cglib

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

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

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

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.junit.functional

Methods in org.hibernate.testing.junit.functional that throw HibernateException
`Session` `FunctionalTestCase.openSession()`
`Session` `FunctionalTestCase.openSession(Interceptor interceptor)`

Uses of HibernateException in org.hibernate.testing.tm

Methods in org.hibernate.testing.tm that throw HibernateException
`void` `ConnectionProviderImpl.close()`
`void` `ConnectionProviderImpl.configure(Properties props)`
`TransactionManager` `TransactionManagerLookupImpl.getTransactionManager(Properties props)`

Uses of HibernateException in org.hibernate.tool.hbm2ddl

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 cfg)` Create a schema exporter for the given Configuration
`SchemaExport(Configuration cfg, Connection connection)` Create a schema exporter for the given Configuration, using the supplied connection for connectivity.
`SchemaExport(Configuration cfg, Properties properties)` Deprecated. properties may be specified via the Configuration object
`SchemaExport(Configuration cfg, Settings settings)` Create a schema exporter for the given Configuration and given settings
`SchemaUpdate(Configuration cfg)`
`SchemaUpdate(Configuration cfg, Properties connectionProperties)`
`SchemaUpdate(Configuration cfg, Settings settings)`
`SchemaValidator(Configuration cfg)`
`SchemaValidator(Configuration cfg, Properties connectionProperties)`
`SchemaValidator(Configuration cfg, Settings settings)`

Uses of HibernateException in org.hibernate.transaction

Methods in org.hibernate.transaction that throw HibernateException
`void` `JTATransaction.begin()` Begin a new transaction.
`void` `JDBCTransaction.begin()` Begin a new transaction.
`void` `CMTTransaction.begin()` Begin a new transaction.
`static TransactionFactory` `TransactionFactoryFactory.buildTransactionFactory(Properties transactionProps)` Create an appropriate transaction factory based on the given configuration properties.
`void` `JTATransaction.commit()` Flush the associated `Session` and end the unit of work (unless we are in `FlushMode.MANUAL`.
`void` `JDBCTransaction.commit()` Flush the associated `Session` and end the unit of work (unless we are in `FlushMode.MANUAL`.
`void` `CMTTransaction.commit()` Flush the associated `Session` and end the unit of work (unless we are in `FlushMode.MANUAL`.
`void` `TransactionFactory.configure(Properties props)` Configure from the given properties.
`void` `JTATransactionFactory.configure(Properties props)` Configure this transaction factory.
`void` `JDBCTransactionFactory.configure(Properties props)` Configure from the given properties.
`void` `CMTTransactionFactory.configure(Properties props)`
`Transaction` `TransactionFactory.createTransaction(JDBCContext jdbcContext, TransactionFactory.Context context)` Begin a transaction and return the associated `Transaction` instance.
`Transaction` `JTATransactionFactory.createTransaction(JDBCContext jdbcContext, TransactionFactory.Context transactionContext)` Begin a transaction and return the associated `Transaction` instance.
`Transaction` `JDBCTransactionFactory.createTransaction(JDBCContext jdbcContext, TransactionFactory.Context transactionContext)` Begin a transaction and return the associated `Transaction` instance.
`Transaction` `CMTTransactionFactory.createTransaction(JDBCContext jdbcContext, TransactionFactory.Context transactionContext)`
`TransactionManager` `WebSphereTransactionManagerLookup.getTransactionManager(Properties props)` Obtain the JTA `TransactionManager`.
`static TransactionManager` `TransactionManagerLookupFactory.getTransactionManager(Properties props)` Convenience method for locating the JTA `TransactionManager` from the given platform config.
`TransactionManager` `TransactionManagerLookup.getTransactionManager(Properties props)` Obtain the JTA `TransactionManager`.
`TransactionManager` `JOnASTransactionManagerLookup.getTransactionManager(Properties props)`
`TransactionManager` `JOTMTransactionManagerLookup.getTransactionManager(Properties props)` Obtain the JTA `TransactionManager`.
`TransactionManager` `JNDITransactionManagerLookup.getTransactionManager(Properties props)` Obtain the JTA `TransactionManager`.
`TransactionManager` `JBossTSStandaloneTransactionManagerLookup.getTransactionManager(Properties props)`
`TransactionManager` `BTMTransactionManagerLookup.getTransactionManager(Properties props)` Obtain the JTA `TransactionManager`.
`static TransactionManagerLookup` `TransactionManagerLookupFactory.getTransactionManagerLookup(Properties props)` Generate the appropriate `TransactionManagerLookup` given the config settings being passed.
`void` `JTATransaction.registerSynchronization(Synchronization sync)` Register a user synchronization callback for this transaction.
`void` `CMTTransaction.registerSynchronization(Synchronization sync)` Register a user synchronization callback for this transaction.
`void` `JTATransaction.rollback()` Force the underlying transaction to roll back.
`void` `JDBCTransaction.rollback()` Force the underlying transaction to roll back.
`void` `CMTTransaction.rollback()` Force the underlying transaction to roll back.

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` `Dom4jEntityTuplizer.getIdentifier(Object entityOrId)` Extract the identifier value from the given entity.
`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[]` `PojoEntityTuplizer.getPropertyValuesToInsert(Object entity, Map mergeMap, SessionImplementor session)` Extract the values of the insertable properties of the entity (including backrefs)
`Object[]` `EntityTuplizer.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` `StringClobType.assemble(Serializable cached, Object owner)` Deprecated.
`Object` `EnumType.assemble(Serializable cached, Object owner)`
`Object` `Type.assemble(Serializable cached, SessionImplementor session, Object owner)` Reconstruct the object from its cached "disassembled" state.
`Object` `SpecialOneToOneType.assemble(Serializable oid, SessionImplementor session, Object owner)`
`Object` `OneToOneType.assemble(Serializable oid, SessionImplementor session, Object owner)`
`Object` `ManyToOneType.assemble(Serializable oid, SessionImplementor session, Object owner)`
`Object` `CustomType.assemble(Serializable cached, SessionImplementor session, Object owner)`
`Object` `CompositeCustomType.assemble(Serializable cached, SessionImplementor session, Object owner)`
`Object` `ComponentType.assemble(Serializable object, SessionImplementor session, Object owner)`
`Object` `CollectionType.assemble(Serializable cached, SessionImplementor session, Object owner)`
`Object` `AnyType.assemble(Serializable cached, SessionImplementor session, Object owner)`
`Object` `AbstractType.assemble(Serializable cached, SessionImplementor session, Object owner)`
`Object` `AbstractStandardBasicType.assemble(Serializable cached, SessionImplementor session, Object owner)`
`Object` `StringClobType.deepCopy(Object value)` Deprecated.
`Object` `EnumType.deepCopy(Object value)`
`Object` `Type.deepCopy(Object value, EntityMode entityMode, SessionFactoryImplementor factory)` Return a deep copy of the persistent state, stopping at entities and at collections.
`Object` `SerializableToBlobType.deepCopy(Object value, EntityMode entityMode, SessionFactoryImplementor factory)`
`Object` `MutableType.deepCopy(Object value, EntityMode entityMode, SessionFactoryImplementor factory)` Deprecated.
`Object` `MetaType.deepCopy(Object value, EntityMode entityMode, SessionFactoryImplementor factory)`
`Object` `CustomType.deepCopy(Object value, EntityMode entityMode, SessionFactoryImplementor factory)`
`Object` `CompositeCustomType.deepCopy(Object value, EntityMode entityMode, SessionFactoryImplementor factory)`
`Object` `ComponentType.deepCopy(Object component, EntityMode entityMode, SessionFactoryImplementor factory)`
`Object` `CollectionType.deepCopy(Object value, EntityMode entityMode, SessionFactoryImplementor factory)`
`Object` `ByteArrayBlobType.deepCopy(Object value, EntityMode entityMode, SessionFactoryImplementor factory)` Deprecated.
`Object` `AnyType.deepCopy(Object value, EntityMode entityMode, SessionFactoryImplementor factory)`
`protected abstract Object` `MutableType.deepCopyNotNull(Object value)` Deprecated.
`protected Object` `AbstractCharArrayType.deepCopyNotNull(Object value)` Deprecated.
`Serializable` `StringClobType.disassemble(Object value)` Deprecated.
`Serializable` `EnumType.disassemble(Object value)`
`Serializable` `Type.disassemble(Object value, SessionImplementor session, Object owner)` Return a cacheable "disassembled" representation of the object.
`Serializable` `SpecialOneToOneType.disassemble(Object value, SessionImplementor session, Object owner)`
`Serializable` `OneToOneType.disassemble(Object value, SessionImplementor session, Object owner)`
`Serializable` `ManyToOneType.disassemble(Object value, SessionImplementor session, Object owner)`
`Serializable` `CustomType.disassemble(Object value, SessionImplementor session, Object owner)`
`Serializable` `CompositeCustomType.disassemble(Object value, SessionImplementor session, Object owner)`
`Serializable` `ComponentType.disassemble(Object value, SessionImplementor session, Object owner)`
`Serializable` `CollectionType.disassemble(Object value, SessionImplementor session, Object owner)`
`Serializable` `AnyType.disassemble(Object value, SessionImplementor session, Object owner)`
`Serializable` `AbstractType.disassemble(Object value, SessionImplementor session, Object owner)`
`Serializable` `AbstractStandardBasicType.disassemble(Object value, SessionImplementor session, Object owner)`
`boolean` `StringClobType.equals(Object x, Object y)` Deprecated.
`boolean` `EnumType.equals(Object x, Object y)`
`Date` `TimestampType.fromStringValue(String xml)`
`T` `StringRepresentableType.fromStringValue(String string)` Consume the given string representation back into this types java form.
`T` `SingleColumnType.fromStringValue(String xml)`
`abstract Object` `NullableType.fromStringValue(String xml)` Deprecated.
`T` `AbstractStandardBasicType.fromStringValue(String xml)`
`Object` `AbstractBynaryType.fromStringValue(String xml)` Deprecated.
`Object` `Type.fromXMLNode(org.dom4j.Node xml, Mapping factory)` Parse the XML representation of an instance.
`Object` `SerializableToBlobType.fromXMLNode(org.dom4j.Node xml, Mapping factory)`
`Object` `NullableType.fromXMLNode(org.dom4j.Node xml, Mapping factory)` Deprecated.
`Object` `MetaType.fromXMLNode(org.dom4j.Node xml, Mapping factory)`
`Object` `EntityType.fromXMLNode(org.dom4j.Node xml, Mapping factory)` Parse the XML representation of an instance.
`Object` `CustomType.fromXMLNode(org.dom4j.Node xml, Mapping factory)`
`Object` `CompositeCustomType.fromXMLNode(org.dom4j.Node xml, Mapping factory)`
`Object` `ComponentType.fromXMLNode(org.dom4j.Node xml, Mapping factory)`
`Object` `CollectionType.fromXMLNode(org.dom4j.Node xml, Mapping factory)`
`Object` `ByteArrayBlobType.fromXMLNode(org.dom4j.Node xml, Mapping factory)` Deprecated.
`Object` `AnyType.fromXMLNode(org.dom4j.Node xml, Mapping factory)`
`T` `XmlRepresentableType.fromXMLString(String xml, Mapping factory)`
`Object` `NullableType.fromXMLString(String xml, Mapping factory)` Deprecated.
`Object` `MetaType.fromXMLString(String xml, Mapping factory)`
`T` `AbstractStandardBasicType.fromXMLString(String xml, Mapping factory)`
`Object` `SingleColumnType.get(ResultSet rs, String name)` Deprecated. Use `SingleColumnType.get(ResultSet, String, SessionImplementor)` instead.
`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` `AbstractSingleColumnStandardBasicType.get(ResultSet rs, String name)` Deprecated. Use `AbstractStandardBasicType.get(ResultSet, String, SessionImplementor)` instead.
`Object` `AbstractLongStringType.get(ResultSet rs, String name)` Deprecated.
`Object` `AbstractBynaryType.get(ResultSet rs, String name)` Deprecated.
`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.
`Object` `AbstractStandardBasicType.get(ResultSet rs, String name, SessionImplementor session)`
`int` `Type.getHashCode(Object x, EntityMode entityMode)` Get a hash code, consistent with persistence "equality".
`int` `Type.getHashCode(Object x, EntityMode entityMode, 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` `CompositeType.getPropertyValue(Object component, int index, SessionImplementor session)` Extract a particular component property value indicated by index.
`Object` `CompositeCustomType.getPropertyValue(Object component, int i, SessionImplementor session)`
`Object` `ComponentType.getPropertyValue(Object component, int i, SessionImplementor session)`
`Object` `AnyType.getPropertyValue(Object component, int i, SessionImplementor session)`
`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, EntityMode entityMode)`
`Object[]` `CompositeType.getPropertyValues(Object component, SessionImplementor session)` Extract the values of the component properties from the given component instance
`Object[]` `CompositeCustomType.getPropertyValues(Object component, SessionImplementor session)`
`Object[]` `ComponentType.getPropertyValues(Object component, SessionImplementor session)`
`Object[]` `AnyType.getPropertyValues(Object component, SessionImplementor session)`
`int` `StringClobType.hashCode(Object x)` Deprecated.
`int` `EnumType.hashCode(Object x)`
`Object` `Type.hydrate(ResultSet rs, String[] names, SessionImplementor session, Object owner)` Retrieve an instance of the mapped class, or the identifier of an entity or collection, from a JDBC resultset.
`Object` `SpecialOneToOneType.hydrate(ResultSet rs, String[] names, SessionImplementor session, Object owner)`
`Object` `OneToOneType.hydrate(ResultSet rs, String[] names, SessionImplementor session, Object owner)`
`Object` `ManyToOneType.hydrate(ResultSet rs, String[] names, SessionImplementor session, Object owner)`
`Object` `ComponentType.hydrate(ResultSet rs, String[] names, SessionImplementor session, Object owner)`
`Object` `AnyType.hydrate(ResultSet rs, String[] names, SessionImplementor session, Object owner)`
`Object` `AbstractType.hydrate(ResultSet rs, String[] names, SessionImplementor session, Object owner)`
`Object` `AbstractStandardBasicType.hydrate(ResultSet rs, String[] names, SessionImplementor session, Object owner)`
`Object` `ComponentType.instantiate(EntityMode entityMode)` This method does not populate the component parent
`Object` `EmbeddedComponentType.instantiate(Object parent, SessionImplementor session)`
`Object` `ComponentType.instantiate(Object parent, SessionImplementor session)`
`PersistentCollection` `IdentifierBagType.instantiate(SessionImplementor session, CollectionPersister persister, Serializable key)`
`PersistentCollection` `CustomCollectionType.instantiate(SessionImplementor session, CollectionPersister persister, Serializable key)`
`PersistentCollection` `BagType.instantiate(SessionImplementor session, CollectionPersister persister, Serializable key)`
`PersistentCollection` `ArrayType.instantiate(SessionImplementor session, CollectionPersister persister, Serializable key)`
`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` `NullableType.isDirty(Object old, Object current, boolean[] checkable, SessionImplementor session)` Deprecated.
`boolean` `MetaType.isDirty(Object old, Object current, boolean[] checkable, SessionImplementor session)`
`boolean` `ManyToOneType.isDirty(Object old, Object current, boolean[] checkable, SessionImplementor session)`
`boolean` `CustomType.isDirty(Object old, Object current, boolean[] checkable, SessionImplementor session)`
`boolean` `CompositeCustomType.isDirty(Object old, Object current, boolean[] checkable, SessionImplementor session)`
`boolean` `ComponentType.isDirty(Object x, Object y, boolean[] checkable, SessionImplementor session)`
`boolean` `CollectionType.isDirty(Object old, Object current, boolean[] checkable, SessionImplementor session)`
`boolean` `AnyType.isDirty(Object old, Object current, boolean[] checkable, SessionImplementor session)`
`boolean` `AbstractLobType.isDirty(Object old, Object current, boolean[] checkable, SessionImplementor session)` Deprecated.
`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` `ComponentType.isDirty(Object x, Object y, SessionImplementor session)`
`boolean` `CollectionType.isDirty(Object old, Object current, SessionImplementor session)`
`boolean` `AbstractType.isDirty(Object old, Object current, SessionImplementor session)`
`boolean` `CustomType.isEqual(Object x, Object y)`
`boolean` `Type.isEqual(Object x, Object y, EntityMode entityMode)` Compare two instances of the class mapped by this type for persistence "equality" (equality of persistent state).
`boolean` `CustomType.isEqual(Object x, Object y, EntityMode entityMode)`
`boolean` `CompositeCustomType.isEqual(Object x, Object y, EntityMode entityMode)`
`boolean` `ComponentType.isEqual(Object x, Object y, EntityMode entityMode)`
`boolean` `Type.isEqual(Object x, Object y, EntityMode entityMode, SessionFactoryImplementor factory)` Compare two instances of the class mapped by this type for persistence "equality" (equality of persistent state).
`boolean` `ComponentType.isEqual(Object x, Object y, EntityMode entityMode, SessionFactoryImplementor factory)`
`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.SessionImplementor)` methods is that here we need to account for "partially" built values.
`boolean` `ManyToOneType.isModified(Object old, Object current, boolean[] checkable, SessionImplementor session)`
`boolean` `ComponentType.isModified(Object old, Object current, boolean[] checkable, SessionImplementor session)`
`boolean` `CollectionType.isModified(Object old, Object current, boolean[] checkable, SessionImplementor session)`
`boolean` `AnyType.isModified(Object old, Object current, boolean[] checkable, SessionImplementor session)`
`boolean` `AbstractType.isModified(Object old, Object current, boolean[] checkable, SessionImplementor session)`
`boolean` `Type.isSame(Object x, Object y, EntityMode entityMode)` Compare two instances of the class mapped by this type for persistence "equality" (equality of persistent state) taking a shortcut for entity references.
`boolean` `ComponentType.isSame(Object x, Object y, EntityMode entityMode)`
`boolean` `AnyType.isSame(Object x, Object y, EntityMode entityMode)`
`boolean` `AbstractType.isSame(Object x, Object y, EntityMode entityMode)`
`Object` `EntityType.loadByUniqueKey(String entityName, String uniqueKeyPropertyName, Object key, SessionImplementor session)` Load an instance by a unique key that is not the primary key.
`T` `SingleColumnType.nullSafeGet(ResultSet rs, String name)` Deprecated. Use `SingleColumnType.nullSafeGet(ResultSet, String, SessionImplementor)` instead
`Object` `NullableType.nullSafeGet(ResultSet rs, String name)` Deprecated.
`T` `AbstractSingleColumnStandardBasicType.nullSafeGet(ResultSet rs, String name)` Deprecated. Use `AbstractStandardBasicType.nullSafeGet(ResultSet, String, SessionImplementor)` instead
`Object` `NullableType.nullSafeGet(ResultSet rs, String[] names)` Deprecated.
`Object` `StringClobType.nullSafeGet(ResultSet rs, String[] names, Object owner)` Deprecated.
`Object` `EnumType.nullSafeGet(ResultSet rs, String[] names, Object owner)`
`Object` `Type.nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)` Retrieve an instance of the mapped class from a JDBC resultset.
`Object` `NullableType.nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)` Deprecated.
`Object` `MetaType.nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)`
`Object` `EntityType.nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)` Retrieve an instance of the mapped class from a JDBC resultset.
`Object` `CustomType.nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)`
`Object` `CompositeCustomType.nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)`
`Object` `ComponentType.nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)`
`Object` `CollectionType.nullSafeGet(ResultSet rs, String[] name, SessionImplementor session, Object owner)`
`Object` `AnyType.nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)`
`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` `Type.nullSafeGet(ResultSet rs, String name, SessionImplementor session, Object owner)` Retrieve an instance of the mapped class from a JDBC resultset.
`Object` `NullableType.nullSafeGet(ResultSet rs, String name, SessionImplementor session, Object owner)` Deprecated.
`Object` `MetaType.nullSafeGet(ResultSet rs, String name, SessionImplementor session, Object owner)`
`Object` `EntityType.nullSafeGet(ResultSet rs, String name, SessionImplementor session, Object owner)` Retrieve an instance of the mapped class from a JDBC resultset.
`Object` `CustomType.nullSafeGet(ResultSet rs, String columnName, SessionImplementor session, Object owner)`
`Object` `CompositeCustomType.nullSafeGet(ResultSet rs, String columnName, SessionImplementor session, Object owner)`
`Object` `ComponentType.nullSafeGet(ResultSet rs, String name, SessionImplementor session, Object owner)`
`Object` `AnyType.nullSafeGet(ResultSet rs, String name, SessionImplementor session, Object owner)`
`Object` `AbstractLobType.nullSafeGet(ResultSet rs, String name, SessionImplementor session, Object owner)` Deprecated.
`void` `StringClobType.nullSafeSet(PreparedStatement st, Object value, int index)` Deprecated.
`void` `NullableType.nullSafeSet(PreparedStatement st, Object value, int index)` Deprecated.
`void` `EnumType.nullSafeSet(PreparedStatement st, Object value, int index)`
`void` `Type.nullSafeSet(PreparedStatement st, Object value, int index, boolean[] settable, SessionImplementor session)` Write an instance of the mapped class to a prepared statement, ignoring some columns.
`void` `NullableType.nullSafeSet(PreparedStatement st, Object value, int index, boolean[] settable, SessionImplementor session)` Deprecated.
`void` `MetaType.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` `CustomType.nullSafeSet(PreparedStatement st, Object value, int index, boolean[] settable, SessionImplementor session)`
`void` `CompositeCustomType.nullSafeSet(PreparedStatement st, Object value, int index, boolean[] settable, SessionImplementor session)`
`void` `ComponentType.nullSafeSet(PreparedStatement st, Object value, int begin, boolean[] settable, SessionImplementor session)`
`void` `CollectionType.nullSafeSet(PreparedStatement st, Object value, int index, boolean[] settable, SessionImplementor session)`
`void` `AnyType.nullSafeSet(PreparedStatement st, Object value, int index, boolean[] settable, SessionImplementor session)`
`void` `AbstractSingleColumnStandardBasicType.nullSafeSet(PreparedStatement st, Object value, int index, boolean[] settable, SessionImplementor session)` Write an instance of the mapped class to a prepared statement, ignoring some columns.
`void` `AbstractLobType.nullSafeSet(PreparedStatement st, Object value, int index, boolean[] settable, SessionImplementor session)` Deprecated.
`void` `Type.nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)` Write an instance of the mapped class to a prepared statement.
`void` `NullableType.nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)` Deprecated.
`void` `MetaType.nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)`
`void` `ManyToOneType.nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)`
`void` `CustomType.nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)`
`void` `CompositeCustomType.nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)`
`void` `ComponentType.nullSafeSet(PreparedStatement st, Object value, int begin, SessionImplementor session)`
`void` `CollectionType.nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)`
`void` `AnyType.nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)`
`void` `AbstractLobType.nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)` Deprecated.
`void` `SingleColumnType.nullSafeSet(PreparedStatement st, T value, int index)` Deprecated. Use `Type.nullSafeSet(PreparedStatement, Object, int, SessionImplementor)` instead.
`void` `AbstractSingleColumnStandardBasicType.nullSafeSet(PreparedStatement st, T value, int index)` Deprecated. Use `AbstractStandardBasicType.nullSafeSet(PreparedStatement, Object, int, SessionImplementor)` instead.
`String` `NullableType.nullSafeToString(Object value)` Deprecated. A null-safe version of `NullableType.toString(Object)`.
`protected String` `CustomCollectionType.renderLoggableString(Object value, SessionFactoryImplementor factory)`
`protected String` `CollectionType.renderLoggableString(Object value, SessionFactoryImplementor factory)`
`Object` `StringClobType.replace(Object original, Object target, Object owner)` Deprecated.
`Object` `EnumType.replace(Object original, Object target, Object owner)`
`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` `SerializableToBlobType.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` `ImmutableType.replace(Object original, Object target, SessionImplementor session, Object owner, Map copyCache)` Deprecated.
`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` `CustomType.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` `ComponentType.replace(Object original, Object target, SessionImplementor session, Object owner, Map copyCache)`
`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` `ByteArrayBlobType.replace(Object original, Object target, SessionImplementor session, Object owner, Map copyCache)` Deprecated.
`Object` `AnyType.replace(Object original, Object target, SessionImplementor session, Object owner, Map copyCache)`
`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` `ComponentType.replace(Object original, Object target, SessionImplementor session, Object owner, Map copyCache, ForeignKeyDirection foreignKeyDirection)`
`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` `CustomCollectionType.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` `Type.resolve(Object value, SessionImplementor session, Object owner)` Map identifiers to entities or collections.
`Object` `EntityType.resolve(Object value, SessionImplementor session, Object owner)` Resolve an identifier or unique key value
`Object` `ComponentType.resolve(Object value, SessionImplementor session, Object owner)`
`Object` `CollectionType.resolve(Object value, SessionImplementor session, Object owner)`
`Object` `AnyType.resolve(Object value, SessionImplementor session, Object owner)`
`Object` `AbstractType.resolve(Object value, SessionImplementor session, Object owner)`
`Object` `AbstractStandardBasicType.resolve(Object value, SessionImplementor session, Object owner)`
`protected Object` `EntityType.resolveIdentifier(Serializable id, SessionImplementor session)` Resolve an identifier via a load.
`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` `ComponentType.semiResolve(Object value, SessionImplementor session, Object owner)`
`Object` `CollectionType.semiResolve(Object value, SessionImplementor session, Object owner)`
`Object` `AnyType.semiResolve(Object value, SessionImplementor session, Object owner)`
`Object` `AbstractType.semiResolve(Object value, SessionImplementor session, Object owner)`
`Object` `AbstractStandardBasicType.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` `AbstractLongStringType.set(PreparedStatement st, Object value, int index)` Deprecated.
`void` `AbstractBynaryType.set(PreparedStatement st, Object value, int index)` Deprecated.
`void` `SingleColumnType.set(PreparedStatement st, T value, int index)` Deprecated. Use `SingleColumnType.set(PreparedStatement, Object, int, SessionImplementor)` instead.
`void` `AbstractSingleColumnStandardBasicType.set(PreparedStatement st, T value, int index)` Deprecated. Use `AbstractStandardBasicType.set(PreparedStatement, Object, int, SessionImplementor)` instead.
`void` `SingleColumnType.set(PreparedStatement st, T value, int index, SessionImplementor session)` Set a parameter value without worrying about the possibility of null values.
`void` `AbstractStandardBasicType.set(PreparedStatement st, T value, int index, SessionImplementor session)`
`void` `CompositeType.setPropertyValues(Object component, Object[] values, EntityMode entityMode)` Inject property values onto the given component instance An optional operation
`void` `CompositeCustomType.setPropertyValues(Object component, Object[] values, EntityMode entityMode)`
`void` `ComponentType.setPropertyValues(Object component, Object[] values, EntityMode entityMode)`
`void` `AnyType.setPropertyValues(Object component, Object[] values, EntityMode entityMode)`
`void` `Type.setToXMLNode(org.dom4j.Node node, Object value, SessionFactoryImplementor factory)` A representation of the value to be embedded in an XML element.
`void` `SerializableToBlobType.setToXMLNode(org.dom4j.Node node, Object value, SessionFactoryImplementor factory)`
`void` `NullableType.setToXMLNode(org.dom4j.Node xml, Object value, SessionFactoryImplementor factory)` Deprecated.
`void` `MetaType.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.
`void` `CustomType.setToXMLNode(org.dom4j.Node node, Object value, SessionFactoryImplementor factory)`
`void` `CompositeCustomType.setToXMLNode(org.dom4j.Node node, Object value, SessionFactoryImplementor factory)`
`void` `ComponentType.setToXMLNode(org.dom4j.Node node, Object value, SessionFactoryImplementor factory)`
`void` `CollectionType.setToXMLNode(org.dom4j.Node node, Object value, SessionFactoryImplementor factory)`
`void` `ByteArrayBlobType.setToXMLNode(org.dom4j.Node node, Object value, SessionFactoryImplementor factory)` Deprecated.
`String` `Type.toLoggableString(Object value, SessionFactoryImplementor factory)` A representation of the value to be embedded in a log file.
`String` `SerializableToBlobType.toLoggableString(Object value, SessionFactoryImplementor factory)`
`String` `MetaType.toLoggableString(Object value, SessionFactoryImplementor factory)`
`String` `CustomType.toLoggableString(Object value, SessionFactoryImplementor factory)`
`String` `CompositeCustomType.toLoggableString(Object value, SessionFactoryImplementor factory)`
`String` `ComponentType.toLoggableString(Object value, SessionFactoryImplementor factory)`
`String` `CollectionType.toLoggableString(Object value, SessionFactoryImplementor factory)`
`String` `ArrayType.toLoggableString(Object value, SessionFactoryImplementor factory)`
`String` `AnyType.toLoggableString(Object value, SessionFactoryImplementor factory)`
`abstract String` `NullableType.toString(Object value)` Deprecated.
`String` `StringRepresentableType.toString(T value)` Render the value to the string representation.
`String` `SingleColumnType.toString(T value)`
`String` `NullableType.toXMLString(Object value, SessionFactoryImplementor pc)` Deprecated.
`String` `MetaType.toXMLString(Object value, SessionFactoryImplementor factory)`
`String` `XmlRepresentableType.toXMLString(T value, SessionFactoryImplementor factory)`
`String` `AbstractStandardBasicType.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` `UserType.deepCopy(Object value)` Return a deep copy of the persistent state, stopping at entities and at collections.
`Object` `CompositeUserType.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` `UserType.equals(Object x, Object y)` Compare two instances of the class mapped by this type for persistence "equality".
`boolean` `CompositeUserType.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` `UserType.hashCode(Object x)` Get a hashcode for the instance, consistent with persistence "equality"
`int` `CompositeUserType.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` `UserType.nullSafeGet(ResultSet rs, String[] names, Object owner)` Deprecated. SessionImplementor will be added as an argument in a future version (see HHH-5968)
`Object` `CompositeUserType.nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)` Retrieve an instance of the mapped class from a JDBC resultset.
`void` `UserType.nullSafeSet(PreparedStatement st, Object value, int index)` Deprecated. SessionImplementor will be added as an argument in a future version (see HHH-5968)
`void` `CompositeUserType.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.

Uses of HibernateException in org.hibernate.util

Methods in org.hibernate.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` `Cloneable.validate()` Checks to ensure the SessionEventListenerConfig is fully configured (basically, that none of the listeners is null).

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