Uses of Class
org.hibernate.HibernateException

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

Uses of HibernateException in org.hibernate
 

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

Methods in org.hibernate that throw HibernateException
 void ScrollableResults.afterLast()
          Go to a location just after the last result
 void ScrollableResults.beforeFirst()
          Go to a location just before first result (this is the initial location)
 void Session.cancelQuery()
          Cancel the execution of the current query.
 void SessionFactory.close()
          Destroy this SessionFactory and release all resources (caches, connection pools, etc).
 void ScrollableResults.close()
          Release resources immediately.
 Connection Session.close()
          End the session by releasing the JDBC connection and cleaning up.
static void Hibernate.close(Iterator iterator)
          Close an Iterator created by iterate() immediately, instead of waiting until the session is closed or disconnected.
 Criteria Criteria.createAlias(String associationPath, String alias)
          Join an association, assigning an alias to the joined association.
 Criteria Criteria.createAlias(String associationPath, String alias, int joinType)
          Deprecated. use Criteria.createAlias(String, String, org.hibernate.sql.JoinType)
 Criteria Criteria.createAlias(String associationPath, String alias, int joinType, Criterion withClause)
          Deprecated. use #createAlias(String, String, JoinType, Criterion
 Criteria Criteria.createAlias(String associationPath, String alias, JoinType joinType)
          Join an association using the specified join-type, assigning an alias to the joined association.
 Criteria Criteria.createAlias(String associationPath, String alias, JoinType joinType, Criterion withClause)
          Join an association using the specified join-type, assigning an alias to the joined association.
 Criteria Criteria.createCriteria(String associationPath)
          Create a new Criteria, "rooted" at the associated entity.
 Criteria Criteria.createCriteria(String associationPath, int joinType)
          Deprecated. use Criteria.createAlias(String, String, org.hibernate.sql.JoinType)
 Criteria Criteria.createCriteria(String associationPath, JoinType joinType)
          Create a new Criteria, "rooted" at the associated entity, using the specified join type.
 Criteria Criteria.createCriteria(String associationPath, String alias)
          Create a new Criteria, "rooted" at the associated entity, assigning the given alias.
 Criteria Criteria.createCriteria(String associationPath, String alias, int joinType)
          Deprecated. use Criteria.createCriteria(String, org.hibernate.sql.JoinType)
 Criteria Criteria.createCriteria(String associationPath, String alias, int joinType, Criterion withClause)
          Deprecated. use Criteria.createCriteria(String, String, org.hibernate.sql.JoinType, org.hibernate.criterion.Criterion)
 Criteria Criteria.createCriteria(String associationPath, String alias, JoinType joinType)
          Create a new Criteria, "rooted" at the associated entity, assigning the given alias and using the specified join type.
 Criteria Criteria.createCriteria(String associationPath, String alias, JoinType joinType, Criterion withClause)
          Create a new Criteria, "rooted" at the associated entity, assigning the given alias and using the specified join type.
 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 its underlying JDBC connection.
<T> T
Session.doReturningWork(ReturningWork<T> work)
          Controller for allowing users to perform JDBC related work using the Connection managed by this Session, returning the result from calling work.execute() (ReturningWork.execute(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 ith 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.
 String[] Query.getReturnAliases()
          Return the HQL select clause aliases (if any)
 Type[] Query.getReturnTypes()
          Return the Hibernate types of the query result set.
 int ScrollableResults.getRowNumber()
          Get the current location in the result set.
 Short ScrollableResults.getShort(int col)
          Convenience method to read a short
 String ScrollableResults.getString(int col)
          Convenience method to read a string
 String ScrollableResults.getText(int col)
          Convenience method to read text
 TimeZone ScrollableResults.getTimeZone(int col)
          Convenience method to read a timezone
static void Hibernate.initialize(Object proxy)
          Force initialization of a proxy or persistent collection.
 boolean Session.isDirty()
          Does this session contain any changes which must be synchronized with the database? In other words, would any DML operations be executed if we flushed this session?
 boolean ScrollableResults.isFirst()
          Is this the first result?
 boolean ScrollableResults.isLast()
          Is this the last result?
 Iterator Query.iterate()
          Return the query results as an Iterator.
 boolean ScrollableResults.last()
          Go to the last result
 List Query.list()
          Return the query results as a List.
 List Criteria.list()
          Get the results.
 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.
 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(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 Session.refresh(String entityName, Object object)
          Re-read the state of the given instance from the underlying database.
 void Session.refresh(String entityName, 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.
 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.
 

Uses of HibernateException in org.hibernate.action.internal
 

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

Constructors in org.hibernate.action.internal 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.action.spi
 

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

Uses of HibernateException in org.hibernate.cache
 

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

Uses of HibernateException in org.hibernate.cache.ehcache
 

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

Uses of HibernateException in org.hibernate.cache.internal
 

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

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

Uses of HibernateException in org.hibernate.cache.spi
 

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

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

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

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

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

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

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

Uses of HibernateException in org.hibernate.cfg
 

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

Methods in org.hibernate.cfg that throw HibernateException
 SessionFactory Configuration.buildSessionFactory()
          Deprecated. Use Configuration.buildSessionFactory(ServiceRegistry) instead
 SessionFactory Configuration.buildSessionFactory(ServiceRegistry serviceRegistry)
          Create a SessionFactory using the properties and mappings in this configuration.
 Settings Configuration.buildSettings(Properties props, ServiceRegistry serviceRegistry)
           
 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.collection.internal
 

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

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

Uses of HibernateException in org.hibernate.collection.spi
 

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

Uses of HibernateException in org.hibernate.context.internal
 

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

Uses of HibernateException in org.hibernate.context.spi
 

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

Uses of HibernateException in org.hibernate.criterion
 

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

Uses of HibernateException in org.hibernate.dialect
 

Methods in org.hibernate.dialect that throw HibernateException
static Dialect Dialect.getDialect()
          Get an instance of the dialect specified by the current System properties.
static Dialect Dialect.getDialect(Properties props)
          Get an instance of the dialect specified by the given properties or by the current System properties.
 String Dialect.getHibernateTypeName(int code)
          Get the name of the Hibernate Type associated with the given Types 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, long length, int precision, int scale)
          Get the name of the database type associated with the given Types typecode with the given storage specification parameters.
 

Uses of HibernateException in org.hibernate.dialect.lock
 

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

Uses of HibernateException in org.hibernate.ejb
 

Methods in org.hibernate.ejb with parameters of type HibernateException
 RuntimeException 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
 Ejb3Configuration Ejb3Configuration.configure(String resource)
          Deprecated.  
 

Uses of HibernateException in org.hibernate.ejb.connection
 

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

Uses of HibernateException in org.hibernate.ejb.internal
 

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

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

Uses of HibernateException in org.hibernate.engine.internal
 

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

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

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

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

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

Uses of HibernateException in org.hibernate.engine.spi
 

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

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

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

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

Methods in org.hibernate.engine.transaction.internal.jdbc that throw HibernateException
<T> T
JdbcIsolationDelegate.delegateWork(WorkExecutorVisitable<T> work, boolean transacted)
           
 boolean JdbcTransaction.isActive()
           
 

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

Methods in org.hibernate.engine.transaction.internal.jta that throw HibernateException
<T> T
JtaIsolationDelegate.delegateWork(WorkExecutorVisitable<T> work, boolean transacted)
           
 boolean JtaTransaction.isActive()
           
 

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

Methods in org.hibernate.engine.transaction.spi that throw HibernateException
 void AbstractTransactionImpl.begin()
           
 void AbstractTransactionImpl.commit()
           
<T> T
IsolationDelegate.delegateWork(WorkExecutorVisitable<T> work, boolean transacted)
          Perform the given work in isolation from current transaction.
 void AbstractTransactionImpl.rollback()
           
 boolean AbstractTransactionImpl.wasRolledBack()
           
 

Uses of HibernateException in org.hibernate.envers
 

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

Uses of HibernateException in org.hibernate.envers.entities
 

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

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

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

Uses of HibernateException in org.hibernate.envers.exception
 

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

Uses of HibernateException in org.hibernate.envers.internal
 

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

Uses of HibernateException in org.hibernate.envers.reader
 

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

Uses of HibernateException in org.hibernate.envers.test.entities.customtype
 

Methods in org.hibernate.envers.test.entities.customtype that throw HibernateException
 Object ParametrizedTestUserType.assemble(Serializable cached, Object owner)
           
 Object CompositeTestUserType.assemble(Serializable cached, SessionImplementor session, Object owner)
           
 Object CompositeTestUserType.deepCopy(Object value)
           
 Object ParametrizedTestUserType.deepCopy(Object value)
           
 Serializable ParametrizedTestUserType.disassemble(Object value)
           
 Serializable CompositeTestUserType.disassemble(Object value, SessionImplementor session)
           
 boolean CompositeTestUserType.equals(Object x, Object y)
           
 boolean ParametrizedTestUserType.equals(Object x, Object y)
           
 Object CompositeTestUserType.getPropertyValue(Object component, int property)
           
 int CompositeTestUserType.hashCode(Object x)
           
 int ParametrizedTestUserType.hashCode(Object x)
           
 Object CompositeTestUserType.nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)
           
 Object ParametrizedTestUserType.nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)
           
 void CompositeTestUserType.nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)
           
 void ParametrizedTestUserType.nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)
           
 Object ParametrizedTestUserType.replace(Object original, Object target, Object owner)
           
 Object CompositeTestUserType.replace(Object original, Object target, SessionImplementor session, Object owner)
           
 void CompositeTestUserType.setPropertyValue(Object component, int property, Object value)
           
 

Uses of HibernateException in org.hibernate.envers.test.entities.ids
 

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

Uses of HibernateException in org.hibernate.event.internal
 

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

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

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

Uses of HibernateException in org.hibernate.event.spi
 

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

Uses of HibernateException in org.hibernate.exception
 

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

Uses of HibernateException in org.hibernate.exception.spi
 

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

Uses of HibernateException in org.hibernate.hql.internal
 

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

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

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

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

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

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

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

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

Uses of HibernateException in org.hibernate.hql.spi
 

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

Uses of HibernateException in org.hibernate.id
 

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

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

Uses of HibernateException in org.hibernate.id.enhanced
 

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

Uses of HibernateException in org.hibernate.internal
 

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

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

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

Uses of HibernateException in org.hibernate.internal.util
 

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

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

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

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

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

Uses of HibernateException in org.hibernate.jdbc
 

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

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

Uses of HibernateException in org.hibernate.jmx
 

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

Uses of HibernateException in org.hibernate.loader
 

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

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

Uses of HibernateException in org.hibernate.loader.collection
 

Methods in org.hibernate.loader.collection that throw HibernateException
 void SubselectOneToManyLoader.initialize(Serializable id, SessionImplementor session)
           
 void CollectionLoader.initialize(Serializable id, SessionImplementor session)
           
 void SubselectCollectionLoader.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)
           
protected  Object[] CriteriaLoader.getResultRow(Object[] row, ResultSet rs, SessionImplementor session)
           
 Type CriteriaQueryTranslator.getType(Criteria subcriteria, String propertyName)
           
 TypedValue CriteriaQueryTranslator.getTypedValue(Criteria subcriteria, String propertyName, Object value)
          Get the a typed value for the given property value.
 Type CriteriaQueryTranslator.getTypeUsingProjection(Criteria subcriteria, String propertyName)
           
 List CriteriaLoader.list(SessionImplementor session)
           
 ScrollableResults CriteriaLoader.scroll(SessionImplementor session, ScrollMode scrollMode)
           
 

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

Uses of HibernateException in org.hibernate.loader.custom
 

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

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

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

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

Uses of HibernateException in org.hibernate.loader.entity
 

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

Uses of HibernateException in org.hibernate.loader.hql
 

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

Uses of HibernateException in org.hibernate.mapping
 

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

Uses of HibernateException in org.hibernate.metadata
 

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

Uses of HibernateException in org.hibernate.metamodel
 

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

Uses of HibernateException in org.hibernate.metamodel.relational
 

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

Uses of HibernateException in org.hibernate.metamodel.source
 

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

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

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

Uses of HibernateException in org.hibernate.persister.collection
 

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

Uses of HibernateException in org.hibernate.persister.entity
 

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

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

Uses of HibernateException in org.hibernate.persister.internal
 

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

Uses of HibernateException in org.hibernate.persister.spi
 

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

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

Uses of HibernateException in org.hibernate.property
 

Methods in org.hibernate.property that throw HibernateException
 Object 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 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 .