Uses of Class
org.hibernate.HibernateException

Packages that use HibernateException
org.hibernate This package defines the central Hibernate APIs. 
org.hibernate.action This package defines "actions" that are scheduled for asycnchronous execution by the event listeners. 
org.hibernate.cache This package defines APIs/SPIs and implementations for the Hibernate second-level cache. 
org.hibernate.cache.entry This package defines formats for disassembled state kept in the second level cache. 
org.hibernate.cfg This package defines APIs for configuring Hibernate, and classes for building the Hibernate configuration-time metamodel. 
org.hibernate.classic This package implements backward-compatibility with Hibernate 2.1 APIs now deprecated in Hibernate3. 
org.hibernate.collection This package defines a framework for collection wrappers. 
org.hibernate.connection This package abstracts the mechanism for obtaining a JDBC connection. 
org.hibernate.context   
org.hibernate.criterion A framework for defining restriction criteria and order criteria. 
org.hibernate.dialect This package abstracts the SQL dialect of the underlying database. 
org.hibernate.dialect.resolver   
org.hibernate.ejb   
org.hibernate.ejb.connection   
org.hibernate.ejb.transaction   
org.hibernate.engine This package contains classes that are "shared" by other packages, and implementations of some key algorithms. 
org.hibernate.engine.query   
org.hibernate.engine.transaction   
org.hibernate.envers.entities   
org.hibernate.envers.entities.mapper.relation.lazy   
org.hibernate.envers.exception   
org.hibernate.event This package defines an event framework for Hibernate. 
org.hibernate.event.def This package defines a default set of event listeners that implements the default behaviors of Hibernate. 
org.hibernate.exception This package is a fork of Apache commons-lang nestable exceptions. 
org.hibernate.hql This package defines the interface between Hibernate and the HQL query parser implementation (to allow switching between the 2.x and 3.0 HQL parsers). 
org.hibernate.hql.ast An ANTLR-based parser for Hibernate Query Language. 
org.hibernate.hql.ast.exec   
org.hibernate.hql.classic This package contains the Hibernate 2.x query parser which is being end-of-lifed. 
org.hibernate.id This package contains internal implementation classes for the main API interfaces. 
org.hibernate.id.enhanced   
org.hibernate.impl This package contains implementations of the central Hibernate APIs, especially the Hibernate session. 
org.hibernate.intercept This package implements an interception mechanism for lazy property fetching, based on CGLIB bytecode instrumentation. 
org.hibernate.jdbc This package abstracts the mechanism for dispatching SQL statements to the database, and implements interaction with JDBC. 
org.hibernate.junit.functional   
org.hibernate.loader This package defines functionality for processing JDBC result sets and returning complex graphs of persistent objects. 
org.hibernate.loader.collection This package defines collection initializers 
org.hibernate.loader.criteria This package defines the criteria query compiler and loader 
org.hibernate.loader.custom This package defines a framework for custom loaders that accept handwritten SQL 
org.hibernate.loader.custom.sql   
org.hibernate.loader.entity This package defines entity loaders 
org.hibernate.loader.hql This package defines a loader for the AST-based query parser 
org.hibernate.mapping This package defines the Hibernate configuration-time metamodel. 
org.hibernate.metadata This package defines an API for accessing the Hibernate runtime metamodel. 
org.hibernate.persister A persister defines a mapping strategy for a collection or entity. 
org.hibernate.persister.collection This package abstracts the persistence mechanism for collections. 
org.hibernate.persister.entity This package abstracts persistence mechanisms for entities, and defines the Hibernate runtime metamodel. 
org.hibernate.pretty Classes for pretty printing things for exception and log messages. 
org.hibernate.property This package abstracts the notion of a "property" of an entity. 
org.hibernate.proxy This package defines a framework for lazy-initializing entity proxies. 
org.hibernate.proxy.dom4j   
org.hibernate.proxy.map   
org.hibernate.proxy.pojo.cglib   
org.hibernate.proxy.pojo.javassist   
org.hibernate.secure Declarative security for CRUD operations on entities. 
org.hibernate.sql.ordering.antlr   
org.hibernate.test.tm Defines a simplified JTA TransactionManager and transactional connection pool designed for use in test suite and simple usage scenarios. 
org.hibernate.tool.hbm2ddl The hbm2ddl tool. 
org.hibernate.transaction This package abstracts the underlying transaction mechanism (JTA or JDBC) and provides strategies for obtaining application server 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.usertype Interfaces for user-defined custom types. 
org.hibernate.util Utility classes. 
 

Uses of HibernateException in org.hibernate
 

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

Methods in org.hibernate that throw HibernateException
 void ScrollableResults.afterLast()
          Go to a location just after the last result
 void ScrollableResults.beforeFirst()
          Go to a location just before first result (this is the initial location)
 void Transaction.begin()
          Begin a new transaction.
 Transaction Session.beginTransaction()
          Begin a unit of work and return the associated Transaction object.
 void Session.cancelQuery()
          Cancel the execution of the current query.
 void SessionFactory.close()
          Destroy this SessionFactory and release all resources (caches, connection pools, etc).
 Connection Session.close()
          End the session by releasing the JDBC connection and cleaning up.
 void ScrollableResults.close()
          Release resources immediately.
static void Hibernate.close(Iterator iterator)
          Close an Iterator created by iterate() immediately, instead of waiting until the session is closed or disconnected.
 void Transaction.commit()
          Flush the associated Session and end the unit of work (unless we are in FlushMode.MANUAL.
 Connection Session.connection()
          Deprecated. (scheduled for removal in 4.x). Replacement depends on need; for doing direct JDBC stuff use Session.doWork(org.hibernate.jdbc.Work); for opening a 'temporary Session' use (TBD).
 Criteria Criteria.createAlias(String associationPath, String alias)
          Join an association, assigning an alias to the joined association.
 Criteria Criteria.createAlias(String associationPath, String alias, int joinType)
          Join an association using the specified join-type, assigning an alias to the joined association.
 Criteria Criteria.createAlias(String associationPath, String alias, int joinType, Criterion withClause)
          Join an association using the specified join-type, assigning an alias to the joined association.
 Criteria Criteria.createCriteria(String associationPath)
          Create a new Criteria, "rooted" at the associated entity.
 Criteria Criteria.createCriteria(String associationPath, int joinType)
          Create a new Criteria, "rooted" at the associated entity, using the specified join type.
 Criteria Criteria.createCriteria(String associationPath, String alias)
          Create a new Criteria, "rooted" at the associated entity, assigning the given alias.
 Criteria Criteria.createCriteria(String associationPath, String alias, int joinType)
          Create a new Criteria, "rooted" at the associated entity, assigning the given alias and using the specified join type.
 Criteria Criteria.createCriteria(String associationPath, String alias, int joinType, Criterion withClause)
          Create a new Criteria, "rooted" at the associated entity, assigning the given alias and using the specified join type.
 Query Session.createFilter(Object collection, String queryString)
          Create a new instance of Query for the given collection and filter string.
 Query Session.createQuery(String queryString)
          Create a new instance of Query for the given HQL query string.
 SQLQuery StatelessSession.createSQLQuery(String queryString)
          Create a new instance of SQLQuery for the given SQL query string.
 SQLQuery Session.createSQLQuery(String queryString)
          Create a new instance of SQLQuery for the given SQL query string.
static Type Hibernate.custom(Class userTypeClass)
          Deprecated. see http://opensource.atlassian.com/projects/hibernate/browse/HHH-5182
static Type Hibernate.custom(Class userTypeClass, Properties parameters)
          Deprecated. see http://opensource.atlassian.com/projects/hibernate/browse/HHH-5182
static Type Hibernate.custom(Class userTypeClass, String[] parameterNames, String[] parameterValues)
          Deprecated. see http://opensource.atlassian.com/projects/hibernate/browse/HHH-5182
 void Session.delete(Object object)
          Remove a persistent instance from the datastore.
 void Session.delete(String entityName, Object object)
          Remove a persistent instance from the datastore.
 Connection Session.disconnect()
          Disconnect the Session from the current JDBC connection.
 void Session.doWork(Work work)
          Controller for allowing users to perform JDBC related work using the Connection managed by this Session.
 void SessionFactory.evict(Class persistentClass)
          Deprecated. Use Cache.evictEntityRegion(Class) accessed through SessionFactory.getCache() instead.
 void SessionFactory.evict(Class persistentClass, Serializable id)
          Deprecated. Use Cache.containsEntity(Class, Serializable) accessed through SessionFactory.getCache() instead.
 void Session.evict(Object object)
          Remove this instance from the session cache.
 void SessionFactory.evictCollection(String roleName)
          Deprecated. Use Cache.evictCollectionRegion(String) accessed through SessionFactory.getCache() instead.
 void SessionFactory.evictCollection(String roleName, Serializable id)
          Deprecated. Use Cache.evictCollection(String,Serializable) accessed through SessionFactory.getCache() instead.
 void SessionFactory.evictEntity(String entityName)
          Deprecated. Use Cache.evictEntityRegion(String) accessed through SessionFactory.getCache() instead.
 void SessionFactory.evictEntity(String entityName, Serializable id)
          Deprecated. Use Cache.evictEntity(String,Serializable) accessed through SessionFactory.getCache() instead.
 void SessionFactory.evictQueries()
          Deprecated. Use Cache.evictQueryRegions() accessed through SessionFactory.getCache() instead.
 void SessionFactory.evictQueries(String cacheRegion)
          Deprecated. Use Cache.evictQueryRegion(String) accessed through SessionFactory.getCache() instead.
 int Query.executeUpdate()
          Execute the update or delete statement.
 boolean ScrollableResults.first()
          Go to the first result
 void Session.flush()
          Force this session to flush.
 Object[] ScrollableResults.get()
          Get the current row of results
 Object Session.get(Class clazz, Serializable id)
          Return the persistent instance of the given entity class with the given identifier, or null if there is no such persistent instance.
 Object Session.get(Class clazz, Serializable id, LockMode lockMode)
          Deprecated. LockMode parameter should be replaced with LockOptions
 Object Session.get(Class clazz, Serializable id, LockOptions lockOptions)
          Return the persistent instance of the given entity class with the given identifier, or null if there is no such persistent instance.
 Object ScrollableResults.get(int i)
          Get the 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.
 Query Session.getNamedQuery(String queryName)
          Obtain an instance of Query for a named query string defined in the mapping file.
 String[] Query.getReturnAliases()
          Return the HQL select clause aliases (if any)
 Type[] Query.getReturnTypes()
          Return the Hibernate types of the query result set.
 int ScrollableResults.getRowNumber()
          Get the current location in the result set.
 Short ScrollableResults.getShort(int col)
          Convenience method to read a short
 String ScrollableResults.getString(int col)
          Convenience method to read a string
 String ScrollableResults.getText(int col)
          Convenience method to read text
 TimeZone ScrollableResults.getTimeZone(int col)
          Convenience method to read a timezone
static void Hibernate.initialize(Object proxy)
          Force initialization of a proxy or persistent collection.
 boolean Transaction.isActive()
          Is this transaction still active?

Again, this only returns information in relation to the local transaction, not the actual underlying transaction.

 boolean Session.isDirty()
          Does this session contain any changes which must be synchronized with the database? In other words, would any DML operations be executed if we flushed this session?
 boolean ScrollableResults.isFirst()
          Is this the first result?
 boolean ScrollableResults.isLast()
          Is this the last result?
 Iterator Query.iterate()
          Return the query results as an Iterator.
 boolean ScrollableResults.last()
          Go to the last result
 List Query.list()
          Return the query results as a List.
 List Criteria.list()
          Get the results.
 Object Session.load(Class theClass, Serializable id)
          Return the persistent instance of the given entity class with the given identifier, assuming that the instance exists.
 Object Session.load(Class theClass, Serializable id, LockMode lockMode)
          Deprecated. LockMode parameter should be replaced with LockOptions
 Object Session.load(Class theClass, Serializable id, LockOptions lockOptions)
          Return the persistent instance of the given entity class with the given identifier, obtaining the specified lock mode, assuming the instance exists.
 void Session.load(Object object, Serializable id)
          Read the persistent state associated with the given identifier into the given transient instance.
 Object Session.load(String entityName, Serializable id)
          Return the persistent instance of the given entity class with the given identifier, assuming that the instance exists.
 Object Session.load(String entityName, Serializable id, LockMode lockMode)
          Deprecated. LockMode parameter should be replaced with LockOptions
 Object Session.load(String entityName, Serializable id, LockOptions lockOptions)
          Return the persistent instance of the given entity class with the given identifier, obtaining the specified lock mode, assuming the instance exists.
 void Session.LockRequest.lock(Object object)
           
 void Session.lock(Object object, LockMode lockMode)
          Deprecated. instead call buildLockRequest(LockMode).lock(object)
 void Session.LockRequest.lock(String entityName, Object object)
           
 void Session.lock(String entityName, Object object, LockMode lockMode)
          Deprecated. instead call buildLockRequest(LockMode).lock(entityName, object)
 Object Session.merge(Object object)
          Copy the state of the given object onto the persistent object with the same identifier.
 Object Session.merge(String entityName, Object object)
          Copy the state of the given object onto the persistent object with the same identifier.
 boolean ScrollableResults.next()
          Advance to the next result
 Session SessionFactory.openSession()
          Open a Session.
 Session SessionFactory.openSession(Interceptor interceptor)
          Open a Session, utilizing the specified Interceptor.
static ConnectionReleaseMode ConnectionReleaseMode.parse(String modeName)
          Determine the correct ConnectionReleaseMode instance based on the given name.
 void Session.persist(Object object)
          Make a transient instance persistent.
 void Session.persist(String entityName, Object object)
          Make a transient instance persistent.
 boolean ScrollableResults.previous()
          Retreat to the previous result
 void Session.reconnect()
          Deprecated. Manual reconnection is only needed in the case of application-supplied connections, in which case the Session.reconnect(java.sql.Connection) for should be used.
 void Session.reconnect(Connection connection)
          Reconnect to the given JDBC connection.
 void Session.refresh(Object object)
          Re-read the state of the given instance from the underlying database.
 void Session.refresh(Object object, LockMode lockMode)
          Deprecated. LockMode parameter should be replaced with LockOptions
 void Session.refresh(Object object, LockOptions lockOptions)
          Re-read the state of the given instance from the underlying database, with the given LockMode.
 void Transaction.registerSynchronization(Synchronization synchronization)
          Register a user synchronization callback for this transaction.
 void Session.replicate(Object object, ReplicationMode replicationMode)
          Persist the state of the given detached instance, reusing the current identifier value.
 void Session.replicate(String entityName, Object object, ReplicationMode replicationMode)
          Persist the state of the given detached instance, reusing the current identifier value.
 void Transaction.rollback()
          Force the underlying transaction to roll back.
 Serializable Session.save(Object object)
          Persist the given transient instance, first assigning a generated identifier.
 Serializable Session.save(String entityName, Object object)
          Persist the given transient instance, first assigning a generated identifier.
 void Session.saveOrUpdate(Object object)
          Either Session.save(Object) or Session.update(Object) the given instance, depending upon resolution of the unsaved-value checks (see the manual for discussion of unsaved-value checking).
 void Session.saveOrUpdate(String entityName, Object object)
          Either Session.save(String, Object) or Session.update(String, Object) the given instance, depending upon resolution of the unsaved-value checks (see the manual for discussion of unsaved-value checking).
 ScrollableResults Query.scroll()
          Return the query results as ScrollableResults.
 ScrollableResults Criteria.scroll()
          Get the results as an instance of ScrollableResults
 boolean ScrollableResults.scroll(int i)
          Scroll an arbitrary number of locations
 ScrollableResults Query.scroll(ScrollMode scrollMode)
          Return the query results as ScrollableResults.
 ScrollableResults Criteria.scroll(ScrollMode scrollMode)
          Get the results as an instance of ScrollableResults based on the given scroll mode.
 Criteria Criteria.setFetchMode(String associationPath, FetchMode mode)
          Specify an association fetching strategy for an association or a collection of values.
 Query Query.setParameter(int position, Object val)
          Bind a value to a JDBC-style query parameter.
 Query Query.setParameter(String name, Object val)
          Bind a value to a named query parameter.
 Query Query.setParameterList(String name, Collection vals)
          Bind multiple values to a named query parameter.
 Query Query.setParameterList(String name, Collection vals, Type type)
          Bind multiple values to a named query parameter.
 Query Query.setParameterList(String name, Object[] vals)
          Bind multiple values to a named query parameter.
 Query Query.setParameterList(String name, Object[] vals, Type type)
          Bind multiple values to a named query parameter.
 Query Query.setParameters(Object[] values, Type[] types)
          Bind values and types to positional parameters.
 Query Query.setProperties(Map bean)
          Bind the values of the given Map for each named parameters of the query, matching key names with parameter names and mapping value types to Hibernate types using hueristics.
 Query Query.setProperties(Object bean)
          Bind the property values of the given bean to named parameters of the query, matching property names with parameter names and mapping property types to Hibernate types using hueristics.
 boolean ScrollableResults.setRowNumber(int rowNumber)
          Set the current location in the result set, numbered from either the first row (row number 0), or the last row (row number -1).
 Object Query.uniqueResult()
          Convenience method to return a single instance that matches the query, or null if the query returns no results.
 Object Criteria.uniqueResult()
          Convenience method to return a single instance that matches the query, or null if the query returns no results.
 void Session.update(Object object)
          Update the persistent instance with the identifier of the given detached instance.
 void Session.update(String entityName, Object object)
          Update the persistent instance with the identifier of the given detached instance.
 void Filter.validate()
          Perform validation of the filter state.
 boolean Transaction.wasCommitted()
          Check if this transaction was successfully committed.
 boolean Transaction.wasRolledBack()
          Was this transaction rolled back or set to rollback only?

This only accounts for actions initiated from this local transaction.

 

Uses of HibernateException in org.hibernate.action
 

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

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

Uses of HibernateException in org.hibernate.cache
 

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

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

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

Uses of HibernateException in org.hibernate.cache.entry
 

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

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

Uses of HibernateException in org.hibernate.cfg
 

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

Methods in org.hibernate.cfg that throw HibernateException
 SessionFactory AnnotationConfiguration.buildSessionFactory()
           
 SessionFactory Configuration.buildSessionFactory()
          Instantiate a new SessionFactory, using the properties and mappings in this configuration.
 Settings Configuration.buildSettings()
          Create an object-oriented view of the configuration properties
 Settings Configuration.buildSettings(Properties props)
           
 AnnotationConfiguration AnnotationConfiguration.configure()
           
 Configuration Configuration.configure()
          Use the mappings and properties specified in an application resource named hibernate.cfg.xml.
 AnnotationConfiguration AnnotationConfiguration.configure(Document document)
           
 Configuration Configuration.configure(Document document)
          Use the mappings and properties specified in the given XML document.
 AnnotationConfiguration AnnotationConfiguration.configure(File configFile)
           
 Configuration Configuration.configure(File configFile)
          Use the mappings and properties specified in the given application file.
 AnnotationConfiguration AnnotationConfiguration.configure(String resource)
           
 Configuration Configuration.configure(String resource)
          Use the mappings and properties specified in the given application resource.
 AnnotationConfiguration AnnotationConfiguration.configure(URL url)
           
 Configuration Configuration.configure(URL url)
          Use the mappings and properties specified in the given document.
protected  AnnotationConfiguration AnnotationConfiguration.doConfigure(org.dom4j.Document doc)
           
protected  Configuration Configuration.doConfigure(org.dom4j.Document doc)
           
protected  AnnotationConfiguration AnnotationConfiguration.doConfigure(InputStream stream, String resourceName)
           
protected  Configuration Configuration.doConfigure(InputStream stream, String resourceName)
          Use the mappings and properties specified in the given application resource.
 String[] Configuration.generateDropSchemaScript(Dialect dialect)
          Generate DDL for dropping tables
 String[] Configuration.generateSchemaCreationScript(Dialect dialect)
          Generate DDL for creating tables
 String[] Configuration.generateSchemaUpdateScript(Dialect dialect, DatabaseMetadata databaseMetadata)
          Generate DDL for altering tables
protected  InputStream Configuration.getConfigurationInputStream(String resource)
          Get the configuration file as an InputStream.
 void Configuration.validateSchema(Dialect dialect, DatabaseMetadata databaseMetadata)
           
 

Uses of HibernateException in org.hibernate.classic
 

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

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

Uses of HibernateException in org.hibernate.collection
 

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

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

Uses of HibernateException in org.hibernate.connection
 

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

Uses of HibernateException in org.hibernate.context
 

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

Uses of HibernateException in org.hibernate.criterion
 

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

Uses of HibernateException in org.hibernate.dialect
 

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

Uses of HibernateException in org.hibernate.dialect.resolver
 

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

Uses of HibernateException in org.hibernate.ejb
 

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

Methods in org.hibernate.ejb that throw HibernateException
 Settings Ejb3Configuration.buildSettings()
           
 Ejb3Configuration Ejb3Configuration.configure(String resource)
           
 

Uses of HibernateException in org.hibernate.ejb.connection
 

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

Uses of HibernateException in org.hibernate.ejb.transaction
 

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

Uses of HibernateException in org.hibernate.engine
 

Methods in org.hibernate.engine that throw HibernateException
 CollectionEntry StatefulPersistenceContext.addInitializedCollection(CollectionPersister persister, PersistentCollection collection, Serializable id)
          add a collection we just pulled out of the cache (does not need initializing)
 CollectionEntry PersistenceContext.addInitializedCollection(CollectionPersister persister, PersistentCollection collection, Serializable id)
          add a collection we just pulled out of the cache (does not need initializing)
 void StatefulPersistenceContext.addInitializedDetachedCollection(CollectionPersister collectionPersister, PersistentCollection collection)
          add an (initialized) collection that was created by another session and passed into update() (ie.
 void PersistenceContext.addInitializedDetachedCollection(CollectionPersister collectionPersister, PersistentCollection collection)
          add an (initialized) collection that was created by another session and passed into update() (ie.
 void StatefulPersistenceContext.addNewCollection(CollectionPersister persister, PersistentCollection collection)
          Add a new collection (ie.
 void PersistenceContext.addNewCollection(CollectionPersister persister, PersistentCollection collection)
          Add a new collection (ie.
 void SessionImplementor.applyNonFlushedChanges(NonFlushedChanges nonFlushedChanges)
          Apply non-flushed changes from a different session to this session.
static int ParameterBinder.bindNamedParameters(PreparedStatement ps, Map namedParams, int start, ParameterBinder.NamedParameterSource source, SessionImplementor session)
           
static int ParameterBinder.bindNamedParameters(PreparedStatement ps, QueryParameters queryParameters, int start, ParameterBinder.NamedParameterSource source, SessionImplementor session)
           
static int ParameterBinder.bindPositionalParameters(PreparedStatement st, Object[] values, Type[] types, int start, SessionImplementor session)
           
static int ParameterBinder.bindPositionalParameters(PreparedStatement st, QueryParameters queryParameters, int start, SessionImplementor session)
           
static int ParameterBinder.bindQueryParameters(PreparedStatement st, QueryParameters queryParameters, int start, ParameterBinder.NamedParameterSource source, SessionImplementor session)
           
 void Cascade.cascade(EntityPersister persister, Object parent)
          Cascade an action from the parent entity instance to all its children.
 void Cascade.cascade(EntityPersister persister, Object parent, Object anything)
          Cascade an action from the parent entity instance to all its children.
abstract  void CascadingAction.cascade(EventSource session, Object child, String entityName, Object anything, boolean isCascadeDeleteEnabled)
          Cascade the action to the child object.
 void Nullability.checkNullability(Object[] values, EntityPersister persister, boolean isUpdate)
          Check nullability of the class persister properties
 void StatefulPersistenceContext.checkUniqueness(EntityKey key, Object object)
          Attempts to check whether the given key represents an entity already loaded within the current session.
 void PersistenceContext.checkUniqueness(EntityKey key, Object object)
          Attempts to check whether the given key represents an entity already loaded within the current session.
 Serializable TransactionHelper.doWorkInNewTransaction(SessionImplementor session)
          Suspend the current transaction and perform work in a new transaction
 void ActionQueue.executeActions()
          Perform all currently queued actions.
 void ActionQueue.executeInserts()
          Perform all currently queued entity-insertion actions.
 int SessionImplementor.executeNativeUpdate(NativeSQLQuerySpecification specification, QueryParameters queryParameters)
          Execute a native SQL update or delete query
 int SessionImplementor.executeUpdate(String query, QueryParameters queryParameters)
          Execute a HQL update or delete query
 Object[] StatefulPersistenceContext.getDatabaseSnapshot(Serializable id, EntityPersister persister)
          Get the current state of the entity as known to the underlying database, or null if there is no corresponding row
 Object[] PersistenceContext.getDatabaseSnapshot(Serializable id, EntityPersister persister)
          Get the current state of the entity as known to the underlying database, or null if there is no corresponding row
static Serializable ForeignKeys.getEntityIdentifierIfNotUnsaved(String entityName, Object object, SessionImplementor session)
          Return the identifier of the persistent or transient object, or throw an exception if the instance is "unsaved" Used by OneToOneType and ManyToOneType to determine what id value should be used for an object that may or may not be associated with the session.
 EntityPersister SessionImplementor.getEntityPersister(String entityName, Object object)
          Get the EntityPersister for any instance
 Object SessionImplementor.getEntityUsingInterceptor(EntityKey key)
          Get the entity instance associated with the given Key, calling the Interceptor if necessary
 Object[] StatefulPersistenceContext.getNaturalIdSnapshot(Serializable id, EntityPersister persister)
           
 Object[] PersistenceContext.getNaturalIdSnapshot(Serializable id, EntityPersister persister)
          Get the values of the natural id fields as known to the underlying database, or null if the entity has no natural id or there is no corresponding row.
 NonFlushedChanges SessionImplementor.getNonFlushedChanges()
          Return changes to this session that have not been flushed yet.
 Collection CollectionEntry.getOrphans(String entityName, PersistentCollection collection)
          Get the collection orphans (entities which were removed from the collection)
 QueryCache SessionFactoryImplementor.getQueryCache(String regionName)
          Get a particular named query cache, or the default cache
 String[] SessionFactoryImplementor.getReturnAliases(String queryString)
          Get the return aliases of a query
 Type[] SessionFactoryImplementor.getReturnTypes(String queryString)
          Get the return types of a query
 String SessionImplementor.guessEntityName(Object entity)
          The guessed entity name for an entity not in an association
 Object SessionImplementor.immediateLoad(String entityName, Serializable id)
          Load an instance immediately.
 void SessionImplementor.initializeCollection(PersistentCollection collection, boolean writing)
          Initialize the collection (if not already initialized)
static void TwoPhaseLoad.initializeEntity(Object entity, boolean readOnly, SessionImplementor session, PreLoadEvent preLoadEvent, PostLoadEvent postLoadEvent)
          Perform the second step of 2-phase load.
 void StatefulPersistenceContext.initializeNonLazyCollections()
          Force initialization of all non-lazy collections encountered during the current two-phase load (actually, this is a no-op, unless this is the "outermost" load)
 void PersistenceContext.initializeNonLazyCollections()
          Force initialization of all non-lazy collections encountered during the current two-phase load (actually, this is a no-op, unless this is the "outermost" load)
 Object SessionImplementor.instantiate(String entityName, Serializable id)
          Instantiate the entity class, initializing with the given identifier
 Object SessionImplementor.internalLoad(String entityName, Serializable id, boolean eager, boolean nullable)
          Load an instance without checking if it was deleted.
static boolean ForeignKeys.isNotTransient(String entityName, Object entity, Boolean assumed, SessionImplementor session)
          Is this instance persistent or detached? If assumed is non-null, don't hit the database to make the determination, instead assume that value; the client code must be prepared to "recover" in the case that this assumed result is incorrect.
static boolean ForeignKeys.isTransient(String entityName, Object entity, Boolean assumed, SessionImplementor session)
          Is this instance, which we know is not persistent, actually transient? If assumed is non-null, don't hit the database to make the determination, instead assume that value; the client code must be prepared to "recover" in the case that this assumed result is incorrect.
 Iterator SessionImplementor.iterate(String query, QueryParameters queryParameters)
          Execute an iterate() query
 Iterator SessionImplementor.iterateFilter(Object collection, String filter, QueryParameters queryParameters)
          Iterate a filter
 List SessionImplementor.list(NativeSQLQuerySpecification spec, QueryParameters queryParameters)
          Execute a native SQL query, and return the results as a fully built list.
 List SessionImplementor.list(String query, QueryParameters queryParameters)
          Execute a find() query
 List SessionImplementor.listCustomQuery(CustomQuery customQuery, QueryParameters queryParameters)
          Execute an SQL Query
 List SessionImplementor.listFilter(Object collection, String filter, QueryParameters queryParameters)
          Execute a filter
 Object StatefulPersistenceContext.narrowProxy(Object proxy, EntityPersister persister, EntityKey key, Object object)
          If the existing proxy is insufficiently "narrow" (derived), instantiate a new proxy and overwrite the registration of the old one.
 Object PersistenceContext.narrowProxy(Object proxy, EntityPersister persister, EntityKey key, Object object)
          If the existing proxy is insufficiently "narrow" (derived), instantiate a new proxy and overwrite the registration of the old one.
 void ForeignKeys.Nullifier.nullifyTransientReferences(Object[] values, Type[] types)
          Nullify all references to entities that have not yet been inserted in the database, where the foreign key points toward that entity
 Session SessionFactoryImplementor.openSession(Connection connection, boolean flushBeforeCompletionEnabled, boolean autoCloseSessionEnabled, ConnectionReleaseMode connectionReleaseMode)
          Open a session conforming to the given parameters.
 Session SessionFactoryImplementor.openTemporarySession()
          Get a nontransactional "current" session for Hibernate EntityManager
 void CollectionEntry.postFlush(PersistentCollection collection)
          Called after a successful flush
static void TwoPhaseLoad.postHydrate(EntityPersister persister, Serializable id, Object[] values, Object rowId, Object object, LockMode lockMode, boolean lazyPropertiesAreUnfetched, SessionImplementor session)
          Register the "hydrated" state of an entity instance, after the first step of 2-phase loading.
 void CollectionEntry.postInitialize(PersistentCollection collection)
           
 void CollectionEntry.preFlush(PersistentCollection collection)
           
 void ActionQueue.prepareActions()
          Prepares the internal action queues for execution.
static void Collections.processReachableCollection(PersistentCollection collection, CollectionType type, Object entity, SessionImplementor session)
          Initialize the role of the collection.
static void Collections.processUnreachableCollection(PersistentCollection coll, SessionImplementor session)
          record the fact that this collection was dereferenced
 Object StatefulPersistenceContext.proxyFor(EntityPersister persister, EntityKey key, Object impl)
          Return the existing proxy associated with the given EntityKey, or the third argument (the entity associated with the key) if no proxy exists.
 Object PersistenceContext.proxyFor(EntityPersister persister, EntityKey key, Object impl)
          Return the existing proxy associated with the given EntityKey, or the third argument (the entity associated with the key) if no proxy exists.
 Object StatefulPersistenceContext.proxyFor(Object impl)
          Return the existing proxy associated with the given EntityKey, or the argument (the entity associated with the key) if no proxy exists.
 Object PersistenceContext.proxyFor(Object impl)
          Return the existing proxy associated with the given EntityKey, or the argument (the entity associated with the key) if no proxy exists.
 ScrollableResults SessionImplementor.scroll(NativeSQLQuerySpecification spec, QueryParameters queryParameters)
          Execute a native SQL query, and return the results as a scrollable result.
 ScrollableResults SessionImplementor.scroll(String query, QueryParameters queryParameters)
          Execute a scroll() query
 ScrollableResults SessionImplementor.scrollCustomQuery(CustomQuery customQuery, QueryParameters queryParameters)
          Execute an SQL Query
 void QueryParameters.traceParameters(SessionFactoryImplementor factory)
           
 Object StatefulPersistenceContext.unproxy(Object maybeProxy)
          Get the entity instance underlying the given proxy, throwing an exception if the proxy is uninitialized.
 Object PersistenceContext.unproxy(Object maybeProxy)
          Get the entity instance underlying the given proxy, throwing an exception if the proxy is uninitialized.
 Object StatefulPersistenceContext.unproxyAndReassociate(Object maybeProxy)
          Possibly unproxy the given reference and reassociate it with the current session.
 Object PersistenceContext.unproxyAndReassociate(Object maybeProxy)
          Possibly unproxy the given reference and reassociate it with the current session.
 

Uses of HibernateException in org.hibernate.engine.query
 

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

Uses of HibernateException in org.hibernate.engine.transaction
 

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

Uses of HibernateException in org.hibernate.envers.entities
 

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

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

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

Uses of HibernateException in org.hibernate.envers.exception
 

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

Uses of HibernateException in org.hibernate.event
 

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

Uses of HibernateException in org.hibernate.event.def
 

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

Uses of HibernateException in org.hibernate.exception
 

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

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

Uses of HibernateException in org.hibernate.hql
 

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

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

Uses of HibernateException in org.hibernate.hql.ast
 

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

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

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

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

Uses of HibernateException in org.hibernate.hql.classic
 

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

Uses of HibernateException in org.hibernate.id
 

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

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

Uses of HibernateException in org.hibernate.id.enhanced
 

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

Uses of HibernateException in org.hibernate.impl
 

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

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

Uses of HibernateException in org.hibernate.intercept
 

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

Uses of HibernateException in org.hibernate.jdbc
 

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

Methods in org.hibernate.jdbc that throw HibernateException
 void NonBatchingBatcher.addToBatch(Expectation expectation)
           
 void BatchingBatcher.addToBatch(Expectation expectation)
           
 void Batcher.addToBatch(Expectation expectation)
          Add an insert / delete / update to the current batch (might be called multiple times for single prepareBatchStatement())
 void Batcher.cancelLastQuery()
          Cancel the current query statement
 void AbstractBatcher.cancelLastQuery()
           
 void Batcher.closeConnection(Connection conn)
          Deprecated. Obtain connections from ConnectionProvider instead
 void AbstractBatcher.closeConnection(Connection conn)
           
 Connection JDBCContext.connection()
           
protected  void NonBatchingBatcher.doExecuteBatch(PreparedStatement ps)
           
protected  void BatchingBatcher.doExecuteBatch(PreparedStatement ps)
           
protected abstract  void AbstractBatcher.doExecuteBatch(PreparedStatement ps)
           
 void Batcher.executeBatch()
          Execute the batch
 void AbstractBatcher.executeBatch()
           
 Connection ConnectionManager.getConnection()
          Retrieves the connection currently managed by this ConnectionManager.
 Transaction JDBCContext.getTransaction()
           
 Connection Batcher.openConnection()
          Deprecated. Obtain connections from ConnectionProvider instead
 Connection AbstractBatcher.openConnection()
           
 int Expectations.BasicExpectation.prepare(PreparedStatement statement)
           
 int Expectations.BasicParamExpectation.prepare(PreparedStatement statement)
           
 int Expectation.prepare(PreparedStatement statement)
          Perform any special statement preparation.
 CallableStatement Batcher.prepareBatchCallableStatement(String sql)
          Get a batchable callable statement to use for inserting / deleting / updating (might be called many times before a single call to executeBatch()).
 CallableStatement AbstractBatcher.prepareBatchCallableStatement(String sql)
           
 PreparedStatement Batcher.prepareBatchStatement(String sql)
          Get a batchable prepared statement to use for inserting / deleting / updating (might be called many times before a single call to executeBatch()).
 PreparedStatement AbstractBatcher.prepareBatchStatement(String sql)
           
 CallableStatement Batcher.prepareCallableQueryStatement(String sql, boolean scrollable, ScrollMode scrollMode)
          Get a prepared statement for use in loading / querying.
 CallableStatement AbstractBatcher.prepareCallableQueryStatement(String sql, boolean scrollable, ScrollMode scrollMode)
           
 CallableStatement Batcher.prepareCallableStatement(String sql)
          Get a non-batchable callable statement to use for inserting / deleting / updating.
 CallableStatement AbstractBatcher.prepareCallableStatement(String sql)
           
 PreparedStatement Batcher.prepareQueryStatement(String sql, boolean scrollable, ScrollMode scrollMode)
          Get a prepared statement for use in loading / querying.
 PreparedStatement AbstractBatcher.prepareQueryStatement(String sql, boolean scrollable, ScrollMode scrollMode)
           
 PreparedStatement Batcher.prepareSelectStatement(String sql)
          Get a non-batchable prepared statement to use for selecting.
 PreparedStatement AbstractBatcher.prepareSelectStatement(String sql)
           
 PreparedStatement Batcher.prepareStatement(String sql)
          Get a non-batchable prepared statement to use for inserting / deleting / updating.
 PreparedStatement AbstractBatcher.prepareStatement(String sql)
           
 PreparedStatement Batcher.prepareStatement(String sql, boolean useGetGeneratedKeys)
          Get a non-batchable prepared statement to use for inserting / deleting / updating, using JDBC3 getGeneratedKeys (Connection.prepareStatement(String, int)).
 PreparedStatement AbstractBatcher.prepareStatement(String sql, boolean getGeneratedKeys)
           
 PreparedStatement Batcher.prepareStatement(String sql, String[] columnNames)
          Get a non-batchable prepared statement to use for inserting / deleting / updating.
 PreparedStatement AbstractBatcher.prepareStatement(String sql, String[] columnNames)
           
 void Expectation.verifyOutcome(int rowCount, PreparedStatement statement, int batchPosition)
          Perform verification of the outcome of the RDBMS operation based on the type of expectation defined.
 

Uses of HibernateException in org.hibernate.junit.functional
 

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

Uses of HibernateException in org.hibernate.loader
 

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

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

Uses of HibernateException in org.hibernate.loader.collection
 

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

Uses of HibernateException in org.hibernate.loader.criteria
 

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

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

Uses of HibernateException in org.hibernate.loader.custom
 

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

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

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

Uses of HibernateException in org.hibernate.loader.entity
 

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

Uses of HibernateException in org.hibernate.loader.hql
 

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

Uses of HibernateException in org.hibernate.mapping
 

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

Uses of HibernateException in org.hibernate.metadata
 

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

Uses of HibernateException in org.hibernate.persister
 

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

Uses of HibernateException in org.hibernate.persister.collection
 

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

Uses of HibernateException in org.hibernate.persister.entity
 

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

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

Uses of HibernateException in org.hibernate.pretty
 

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

Uses of HibernateException in org.hibernate.property
 

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

Uses of HibernateException in org.hibernate.proxy
 

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

Uses of HibernateException in org.hibernate.proxy.dom4j
 

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

Uses of HibernateException in org.hibernate.proxy.map
 

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

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

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

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

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

Uses of HibernateException in org.hibernate.secure
 

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

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

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

Uses of HibernateException in org.hibernate.test.tm
 

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

Uses of HibernateException in org.hibernate.tool.hbm2ddl
 

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

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