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 and implementations for the second-level cache and query 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.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.event This package defines an event framework for Hibernate. 
org.hibernate.event.def This package defines a default set of event listeners that implements the default behaviors of Hibernate. 
org.hibernate.exception This package is a fork of Apache commons-lang nestable exceptions. 
org.hibernate.hql This package defines the interface between Hibernate and the HQL query parser implementation (to allow switching between the 2.x and 3.0 HQL parsers). 
org.hibernate.hql.ast An ANTLR-based parser for Hibernate Query Language. 
org.hibernate.hql.ast.exec   
org.hibernate.hql.classic This package contains the Hibernate 2.x query parser which is being end-of-lifed. 
org.hibernate.id This package contains internal implementation classes for the main API interfaces. 
org.hibernate.id.enhanced   
org.hibernate.impl This package contains implementations of the central Hibernate APIs, especially the Hibernate session. 
org.hibernate.intercept This package implements an interception mechanism for lazy property fetching, based on CGLIB bytecode instrumentation. 
org.hibernate.jdbc This package abstracts the mechanism for dispatching SQL statements to the database, and implements interaction with JDBC. 
org.hibernate.jmx This package exposes a Hibernate instance via JMX. 
org.hibernate.loader This package defines functionality for processing JDBC result sets and returning complex graphs of persistent objects. 
org.hibernate.loader.collection This package defines collection initializers  
org.hibernate.loader.criteria This package defines the criteria query compiler and loader  
org.hibernate.loader.custom This package defines a framework for custom loaders that accept handwritten SQL  
org.hibernate.loader.custom.sql   
org.hibernate.loader.entity This package defines entity loaders  
org.hibernate.loader.hql This package defines a loader for the AST-based query parser  
org.hibernate.mapping This package defines the Hibernate configuration-time metamodel. 
org.hibernate.metadata This package defines an API for accessing the Hibernate runtime metamodel. 
org.hibernate.persister A persister defines a mapping strategy for a collection or entity. 
org.hibernate.persister.collection This package abstracts the persistence mechanism for collections. 
org.hibernate.persister.entity This package abstracts persistence mechanisms for entities, and defines the Hibernate runtime metamodel. 
org.hibernate.pretty Classes for pretty printing things for exception and log messages. 
org.hibernate.property This package abstracts the notion of a "property" of an entity. 
org.hibernate.proxy This package defines a framework for lazy-initializing entity proxies. 
org.hibernate.proxy.dom4j   
org.hibernate.proxy.map   
org.hibernate.proxy.pojo.cglib   
org.hibernate.proxy.pojo.javassist   
org.hibernate.secure Declarative security for CRUD operations on entities. 
org.hibernate.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 This package defines a runtime metamodel for entities at the object level and abstracts the differences between the various entity modes. 
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 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 PersistentObjectException
          Thrown when the user passes a persistent instance to a Session method that expects a transient instance.
 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 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 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 Filter.validate()
          Perform validation of the filter state.
 void Transaction.begin()
          Begin a new transaction.
 void Transaction.commit()
          Flush the associated Session and end the unit of work (unless we are in FlushMode.NEVER.
 void Transaction.rollback()
          Force the underlying transaction to roll back.
 boolean Transaction.wasRolledBack()
          Was this transaction rolled back or set to rollback only?

This only accounts for actions initiated from this local transaction.

 boolean Transaction.wasCommitted()
          Check if this transaction was successfully committed.
 boolean Transaction.isActive()
          Is this transaction still active?

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

 void Transaction.registerSynchronization(Synchronization synchronization)
          Register a user synchronization callback for this transaction.
 Session SessionFactory.openSession(Interceptor interceptor)
          Create database connection and open a Session on it, specifying an interceptor.
 Session SessionFactory.openSession()
          Create database connection and open a Session on it.
 Session SessionFactory.getCurrentSession()
          Obtains the current session.
 ClassMetadata SessionFactory.getClassMetadata(Class persistentClass)
          Get the ClassMetadata associated with the given entity class
 ClassMetadata SessionFactory.getClassMetadata(String entityName)
          Get the ClassMetadata associated with the given entity name
 CollectionMetadata SessionFactory.getCollectionMetadata(String roleName)
          Get the CollectionMetadata associated with the named collection role
 Map SessionFactory.getAllClassMetadata()
          Get all ClassMetadata as a Map from entityname String to metadata object
 Map SessionFactory.getAllCollectionMetadata()
          Get all CollectionMetadata as a Map from role name to metadata object
 void SessionFactory.close()
          Destroy this SessionFactory and release all resources (caches, connection pools, etc).
 void SessionFactory.evict(Class persistentClass)
          Evict all entries from the second-level cache.
 void SessionFactory.evict(Class persistentClass, Serializable id)
          Evict an entry from the second-level cache.
 void SessionFactory.evictEntity(String entityName)
          Evict all entries from the second-level cache.
 void SessionFactory.evictEntity(String entityName, Serializable id)
          Evict an entry from the second-level cache.
 void SessionFactory.evictCollection(String roleName)
          Evict all entries from the second-level cache.
 void SessionFactory.evictCollection(String roleName, Serializable id)
          Evict an entry from the second-level cache.
 void SessionFactory.evictQueries()
          Evict any query result sets cached in the default query cache region.
 void SessionFactory.evictQueries(String cacheRegion)
          Evict any query result sets cached in the named query cache region.
 FilterDefinition SessionFactory.getFilterDefinition(String filterName)
          Obtain the definition of a filter by name.
 Type[] Query.getReturnTypes()
          Return the Hibernate types of the query result set.
 String[] Query.getReturnAliases()
          Return the HQL select clause aliases (if any)
 String[] Query.getNamedParameters()
          Return the names of all named parameters of the query.
 Iterator Query.iterate()
          Return the query results as an Iterator.
 ScrollableResults Query.scroll()
          Return the query results as ScrollableResults.
 ScrollableResults Query.scroll(ScrollMode scrollMode)
          Return the query results as ScrollableResults.
 List Query.list()
          Return the query results as a List.
 Object Query.uniqueResult()
          Convenience method to return a single instance that matches the query, or null if the query returns no results.
 int Query.executeUpdate()
          Execute the update or delete statement.
 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.setParameters(Object[] values, Type[] types)
          Bind values and types to positional parameters.
 Query Query.setParameterList(String name, Collection vals, Type type)
          Bind multiple values 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, Object[] 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.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.
 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.
 void Session.flush()
          Force this session to flush.
 Connection Session.connection()
          Deprecated. To be replaced with a SPI for performing work against the connection; scheduled for removal in 4.x
 Connection Session.close()
          End the session by releasing the JDBC connection and cleaning up.
 void Session.cancelQuery()
          Cancel the execution of the current query.
 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?
 Serializable Session.getIdentifier(Object object)
          Return the identifier value of the given entity as associated with this session.
 void Session.evict(Object object)
          Remove this instance from the session cache.
 Object Session.load(Class theClass, Serializable id, LockMode lockMode)
          Return the persistent instance of the given entity class with the given identifier, obtaining the specified lock mode, assuming the instance exists.
 Object Session.load(String entityName, Serializable id, LockMode lockMode)
          Return the persistent instance of the given entity class with the given identifier, obtaining the specified lock mode, assuming the instance exists.
 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(String entityName, Serializable id)
          Return the persistent instance of the given entity class with the given identifier, assuming that the instance exists.
 void Session.load(Object object, Serializable id)
          Read the persistent state associated with the given identifier into the given transient instance.
 void Session.replicate(Object object, ReplicationMode replicationMode)
          Persist the state of the given detached instance, reusing the current identifier value.
 void Session.replicate(String entityName, Object object, ReplicationMode replicationMode)
          Persist the state of the given detached instance, reusing the current identifier value.
 Serializable Session.save(Object object)
          Persist the given transient instance, first assigning a generated identifier.
 Serializable Session.save(String entityName, Object object)
          Persist the given transient instance, first assigning a generated identifier.
 void Session.saveOrUpdate(Object object)
          Either Session.save(Object) or Session.update(Object) the given instance, depending upon resolution of the unsaved-value checks (see the manual for discussion of unsaved-value checking).
 void Session.saveOrUpdate(String entityName, Object object)
          Either Session.save(String, Object) or Session.update(String, Object) the given instance, depending upon resolution of the unsaved-value checks (see the manual for discussion of unsaved-value checking).
 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.
 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.
 void Session.persist(Object object)
          Make a transient instance persistent.
 void Session.persist(String entityName, Object object)
          Make a transient instance persistent.
 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.
 void Session.lock(Object object, LockMode lockMode)
          Obtain the specified lock level upon the given object.
 void Session.lock(String entityName, Object object, LockMode lockMode)
          Obtain the specified lock level upon the given object.
 void Session.refresh(Object object)
          Re-read the state of the given instance from the underlying database.
 void Session.refresh(Object object, LockMode lockMode)
          Re-read the state of the given instance from the underlying database, with the given LockMode.
 LockMode Session.getCurrentLockMode(Object object)
          Determine the current lock mode of the given object.
 Transaction Session.beginTransaction()
          Begin a unit of work and return the associated Transaction object.
 Query Session.createQuery(String queryString)
          Create a new instance of Query for the given HQL query string.
 SQLQuery Session.createSQLQuery(String queryString)
          Create a new instance of SQLQuery for the given SQL query string.
 Query Session.createFilter(Object collection, String queryString)
          Create a new instance of Query for the given collection and filter string.
 Query Session.getNamedQuery(String queryName)
          Obtain an instance of Query for a named query string defined in the mapping file.
 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)
          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(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)
          Return the persistent instance of the given entity class with the given identifier, or null if there is no such persistent instance.
 String Session.getEntityName(Object object)
          Return the entity name for a persistent entity
 Connection Session.disconnect()
          Disconnect the Session from the current JDBC connection.
 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.
static ConnectionReleaseMode ConnectionReleaseMode.parse(String modeName)
          Determine the correct ConnectionReleaseMode instance based on the given name.
 SQLQuery StatelessSession.createSQLQuery(String queryString)
          Create a new instance of SQLQuery for the given SQL query string.
static Type Hibernate.custom(Class userTypeClass)
          A Hibernate custom type.
static Type Hibernate.custom(Class userTypeClass, String[] parameterNames, String[] parameterValues)
          A Hibernate parameterizable custom type.
static Type Hibernate.custom(Class userTypeClass, Properties parameters)
          A Hibernate parameterizable custom type.
static void Hibernate.initialize(Object proxy)
          Force initialization of a proxy or persistent collection.
static void Hibernate.close(Iterator iterator)
          Close an Iterator created by iterate() immediately, instead of waiting until the session is closed or disconnected.
 boolean ScrollableResults.next()
          Advance to the next result
 boolean ScrollableResults.previous()
          Retreat to the previous result
 boolean ScrollableResults.scroll(int i)
          Scroll an arbitrary number of locations
 boolean ScrollableResults.last()
          Go to the last result
 boolean ScrollableResults.first()
          Go to the first result
 void ScrollableResults.beforeFirst()
          Go to a location just before first result (this is the initial location)
 void ScrollableResults.afterLast()
          Go to a location just after the last result
 boolean ScrollableResults.isFirst()
          Is this the first result?
 boolean ScrollableResults.isLast()
          Is this the last result?
 void ScrollableResults.close()
          Release resources immediately.
 Object[] ScrollableResults.get()
          Get the current row of results
 Object ScrollableResults.get(int i)
          Get the ith object in the current row of results, without initializing any other results in the row.
 Integer ScrollableResults.getInteger(int col)
          Convenience method to read an integer
 Long ScrollableResults.getLong(int col)
          Convenience method to read a long
 Float ScrollableResults.getFloat(int col)
          Convenience method to read a float
 Boolean ScrollableResults.getBoolean(int col)
          Convenience method to read a boolean
 Double ScrollableResults.getDouble(int col)
          Convenience method to read a double
 Short ScrollableResults.getShort(int col)
          Convenience method to read a short
 Byte ScrollableResults.getByte(int col)
          Convenience method to read a byte
 Character ScrollableResults.getCharacter(int col)
          Convenience method to read a character
 byte[] ScrollableResults.getBinary(int col)
          Convenience method to read a binary
 String ScrollableResults.getText(int col)
          Convenience method to read text
 Blob ScrollableResults.getBlob(int col)
          Convenience method to read a blob
 Clob ScrollableResults.getClob(int col)
          Convenience method to read a clob
 String ScrollableResults.getString(int col)
          Convenience method to read a string
 BigDecimal ScrollableResults.getBigDecimal(int col)
          Convenience method to read a big_decimal
 BigInteger ScrollableResults.getBigInteger(int col)
          Convenience method to read a big_integer
 Date ScrollableResults.getDate(int col)
          Convenience method to read a date, time or timestamp
 Locale ScrollableResults.getLocale(int col)
          Convenience method to read a locale
 Calendar ScrollableResults.getCalendar(int col)
          Convenience method to read a calendar or calendar_date
 TimeZone ScrollableResults.getTimeZone(int col)
          Convenience method to read a timezone
 int ScrollableResults.getRowNumber()
          Get the current location in the result set.
 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).
 Criteria Criteria.setFetchMode(String associationPath, FetchMode mode)
          Specify an association fetching strategy for an association or a collection of values.
 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.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.
 List Criteria.list()
          Get the results.
 ScrollableResults Criteria.scroll()
          Get the results as an instance of ScrollableResults
 ScrollableResults Criteria.scroll(ScrollMode scrollMode)
          Get the results as an instance of ScrollableResults based on the given scroll mode.
 Object Criteria.uniqueResult()
          Convenience method to return a single instance that matches the query, or null if the query returns no results.
 

Uses of HibernateException in org.hibernate.action
 

Methods in org.hibernate.action that throw HibernateException
 void EntityUpdateAction.execute()
           
 void CollectionRecreateAction.execute()
           
 void CollectionUpdateAction.execute()
           
 void EntityDeleteAction.execute()
           
 void EntityDeleteAction.afterTransactionCompletion(boolean success)
           
 void EntityInsertAction.execute()
           
 void EntityInsertAction.afterTransactionCompletion(boolean success)
           
 void BulkOperationCleanupAction.afterTransactionCompletion(boolean success)
           
 void BulkOperationCleanupAction.beforeExecutions()
           
 void BulkOperationCleanupAction.execute()
           
 void EntityIdentityInsertAction.execute()
           
 void EntityIdentityInsertAction.afterTransactionCompletion(boolean success)
           
 void Executable.beforeExecutions()
          Called before executing any actions
 void Executable.execute()
          Execute this action
 void Executable.afterTransactionCompletion(boolean success)
          Called after the transaction completes
 void CollectionRemoveAction.execute()
           
 

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

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
static CacheConcurrencyStrategy CacheFactory.createCache(String concurrencyStrategy, String regionName, boolean mutable, Settings settings, Properties properties)
           
 boolean QueryCache.put(QueryKey key, Type[] returnTypes, List result, boolean isNaturalKeyLookup, SessionImplementor session)
           
 List QueryCache.get(QueryKey key, Type[] returnTypes, boolean isNaturalKeyLookup, Set spaces, SessionImplementor session)
           
 boolean UpdateTimestampsCache.isUpToDate(Set spaces, Long timestamp)
           
 QueryCache QueryCacheFactory.getQueryCache(String regionName, UpdateTimestampsCache updateTimestampsCache, Settings settings, Properties props)
           
 boolean StandardQueryCache.put(QueryKey key, Type[] returnTypes, List result, boolean isNaturalKeyLookup, SessionImplementor session)
           
 List StandardQueryCache.get(QueryKey key, Type[] returnTypes, boolean isNaturalKeyLookup, Set spaces, SessionImplementor session)
           
 QueryCache StandardQueryCacheFactory.getQueryCache(String regionName, UpdateTimestampsCache updateTimestampsCache, Settings settings, Properties props)
           
 

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

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
 

Methods in org.hibernate.cfg that throw HibernateException
 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
 void Configuration.validateSchema(Dialect dialect, DatabaseMetadata databaseMetadata)
           
 SessionFactory Configuration.buildSessionFactory()
          Instantiate a new SessionFactory, using the properties and mappings in this configuration.
protected  InputStream Configuration.getConfigurationInputStream(String resource)
          Get the configuration file as an InputStream.
 Configuration Configuration.configure()
          Use the mappings and properties specified in an application resource named hibernate.cfg.xml.
 Configuration Configuration.configure(String resource)
          Use the mappings and properties specified in the given application resource.
 Configuration Configuration.configure(URL url)
          Use the mappings and properties specified in the given document.
 Configuration Configuration.configure(File configFile)
          Use the mappings and properties specified in the given application file.
protected  Configuration Configuration.doConfigure(InputStream stream, String resourceName)
          Use the mappings and properties specified in the given application resource.
 Configuration Configuration.configure(org.w3c.dom.Document document)
          Use the mappings and properties specified in the given XML document.
protected  Configuration Configuration.doConfigure(org.dom4j.Document doc)
           
 Settings Configuration.buildSettings()
          Create an object-oriented view of the configuration properties
 Settings Configuration.buildSettings(Properties props)
           
 

Constructors in org.hibernate.cfg that throw HibernateException
SettingsFactory()
           
 

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

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

Uses of HibernateException in org.hibernate.connection
 

Methods in org.hibernate.connection that throw HibernateException
 void DatasourceConnectionProvider.configure(Properties props)
           
 void DriverManagerConnectionProvider.configure(Properties props)
           
 void C3P0ConnectionProvider.configure(Properties props)
          Initialize the connection provider from given properties.
 void ConnectionProvider.configure(Properties props)
          Initialize the connection provider from given properties.
 void ConnectionProvider.close()
          Release all resources held by this provider.
 void ProxoolConnectionProvider.configure(Properties props)
          Initialize the connection provider from given properties.
 void ProxoolConnectionProvider.close()
          Release all resources held by this provider.
 void UserSuppliedConnectionProvider.configure(Properties props)
           
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)
          Instantiate a ConnectionProvider using given properties.
 

Uses of HibernateException in org.hibernate.context
 

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

Uses of HibernateException in org.hibernate.criterion
 

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

Uses of HibernateException in org.hibernate.dialect
 

Methods in org.hibernate.dialect that throw HibernateException
static Dialect DialectFactory.buildDialect(Properties props, String databaseName, int databaseMajorVersion)
          Builds an appropriate Dialect instance.
 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.
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.getTypeName(int code)
          Get the name of the database type associated with the given 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.
 String Dialect.getHibernateTypeName(int code)
          Get the name of the Hibernate Type associated with th 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.
 

Uses of HibernateException in org.hibernate.engine
 

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

Uses of HibernateException in org.hibernate.engine.query
 

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

Uses of HibernateException in org.hibernate.engine.transaction
 

Methods in org.hibernate.engine.transaction that throw HibernateException
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 Isolater.JtaDelegate.delegateWork(IsolatedWork work, boolean transacted)
           
 void Isolater.JdbcDelegate.delegateWork(IsolatedWork work, boolean transacted)
           
 void IsolatedWork.doWork(Connection connection)
          Perform the actual work to be done.
 

Uses of HibernateException in org.hibernate.event
 

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

Uses of HibernateException in org.hibernate.event.def
 

Methods in org.hibernate.event.def that throw HibernateException
protected  void AbstractLockUpgradeEventListener.upgradeLock(Object object, EntityEntry entry, LockMode requestedLockMode, SessionImplementor source)
          Performs a pessimistic lock upgrade on a given entity, if needed.
 void DefaultEvictEventListener.onEvict(EvictEvent event)
          Handle the given evict event.
protected  void DefaultEvictEventListener.doEvict(Object object, EntityKey key, EntityPersister persister, EventSource session)
           
 void DefaultAutoFlushEventListener.onAutoFlush(AutoFlushEvent event)
          Handle the given auto-flush event.
 void DefaultPersistEventListener.onPersist(PersistEvent event)
          Handle the given create event.
 void DefaultPersistEventListener.onPersist(PersistEvent event, Map createCache)
          Handle the given create event.
protected  void DefaultPersistEventListener.entityIsTransient(PersistEvent event, Map createCache)
          Handle the given create event.
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
 void DefaultLockEventListener.onLock(LockEvent event)
          Handle the given lock event.
 void DefaultDeleteEventListener.onDelete(DeleteEvent event)
          Handle the given delete event.
 void DefaultDeleteEventListener.onDelete(DeleteEvent event, Set transientEntities)
          Handle the given delete event.
protected  void DefaultDeleteEventListener.cascadeBeforeDelete(EventSource session, EntityPersister persister, Object entity, EntityEntry entityEntry, Set transientEntities)
           
protected  void DefaultDeleteEventListener.cascadeAfterDelete(EventSource session, EntityPersister persister, Object entity, Set transientEntities)
           
 void DefaultRefreshEventListener.onRefresh(RefreshEvent event)
           
 void DefaultRefreshEventListener.onRefresh(RefreshEvent event, Map refreshedAlready)
          Handle the given refresh event.
protected  Serializable DefaultSaveOrUpdateEventListener.entityIsPersistent(SaveOrUpdateEvent event)
           
protected  void DefaultSaveOrUpdateEventListener.performUpdate(SaveOrUpdateEvent event, Object entity, EntityPersister persister)
           
 void DefaultFlushEntityEventListener.checkId(Object object, EntityPersister persister, Serializable id, EntityMode entityMode)
          make sure user didn't mangle the id
 void DefaultFlushEntityEventListener.onFlushEntity(FlushEntityEvent event)
          Flushes a single entity's state to the database, by scheduling an update action, if necessary
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  void DefaultFlushEntityEventListener.dirtyCheck(FlushEntityEvent event)
          Perform a dirty check, and attach the results to the event
 void DefaultLoadEventListener.onLoad(LoadEvent event, LoadEventListener.LoadType loadType)
          Handle the given load event.
protected  Object DefaultLoadEventListener.load(LoadEvent event, EntityPersister persister, EntityKey keyToLoad, LoadEventListener.LoadType options)
          Perfoms the load of an entity.
protected  Object DefaultLoadEventListener.proxyOrLoad(LoadEvent event, EntityPersister persister, EntityKey keyToLoad, LoadEventListener.LoadType options)
          Based on configured options, will either return a pre-existing proxy, generate a new proxy, or perform an actual load.
protected  Object DefaultLoadEventListener.lockAndLoad(LoadEvent event, EntityPersister persister, EntityKey keyToLoad, LoadEventListener.LoadType options, SessionImplementor source)
          If the class to be loaded has been configured with a cache, then lock given id in that cache and then perform the load.
protected  Object DefaultLoadEventListener.doLoad(LoadEvent event, EntityPersister persister, EntityKey keyToLoad, LoadEventListener.LoadType options)
          Coordinates the efforts to load a given entity.
protected  Object DefaultLoadEventListener.loadFromDatasource(LoadEvent event, EntityPersister persister, EntityKey keyToLoad, LoadEventListener.LoadType options)
          Performs the process of loading an entity from the configured underlying datasource.
protected  Object DefaultLoadEventListener.loadFromSessionCache(LoadEvent event, EntityKey keyToLoad, LoadEventListener.LoadType options)
          Attempts to locate the entity in the session-level cache.
protected  Object DefaultLoadEventListener.loadFromSecondLevelCache(LoadEvent event, EntityPersister persister, LoadEventListener.LoadType options)
          Attempts to load the entity from the second-level cache.
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  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 AbstractFlushingEventListener.postFlush(SessionImplementor session)
          1.
 void DefaultDirtyCheckEventListener.onDirtyCheck(DirtyCheckEvent event)
          Handle the given dirty-check event.
protected  Serializable DefaultUpdateEventListener.getUpdateId(Object entity, EntityPersister persister, Serializable requestedId, EntityMode entityMode)
          If the user specified an id, assign it to the instance and use that, otherwise use the id already assigned to the instance
 void DefaultFlushEventListener.onFlush(FlushEvent event)
          Handle the given flush event.
 void DefaultInitializeCollectionEventListener.onInitializeCollection(InitializeCollectionEvent event)
          called by a collection that wants to initialize itself
 void DefaultMergeEventListener.onMerge(MergeEvent event)
          Handle the given merge event.
 void DefaultMergeEventListener.onMerge(MergeEvent event, Map copiedAlready)
          Handle the given merge event.
protected  void DefaultMergeEventListener.cascadeAfterSave(EventSource source, EntityPersister persister, Object entity, Object anything)
          Cascade behavior is redefined by this subclass, disable superclass behavior
protected  void DefaultMergeEventListener.cascadeBeforeSave(EventSource source, EntityPersister persister, Object entity, Object anything)
          Cascade behavior is redefined by this subclass, disable superclass behavior
 void AbstractVisitor.processEntityPropertyValues(Object[] values, Type[] types)
          Dispatch each property value to processValue().
 

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
 List QueryTranslator.list(SessionImplementor session, QueryParameters queryParameters)
          Perform a list operation given the underlying query definition.
 Iterator QueryTranslator.iterate(QueryParameters queryParameters, EventSource session)
          Perform an iterate operation given the underlying query defintion.
 ScrollableResults QueryTranslator.scroll(QueryParameters queryParameters, SessionImplementor session)
          Perform a scroll operation given the underlying query defintion.
 int QueryTranslator.executeUpdate(QueryParameters queryParameters, SessionImplementor session)
          Perform a bulk update/delete operation given the underlying query defintion.
 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
          {@inheritDoc}
 class QuerySyntaxException
          Exception thrown when there is a syntax error in the HQL.
 

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

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

Methods in org.hibernate.hql.ast.exec that throw HibernateException
 int MultiTableDeleteExecutor.execute(QueryParameters parameters, SessionImplementor session)
           
 int BasicExecutor.execute(QueryParameters parameters, SessionImplementor session)
           
 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)
           
 

Uses of HibernateException in org.hibernate.hql.classic
 

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

Uses of HibernateException in org.hibernate.id.enhanced
 

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

Uses of HibernateException in org.hibernate.impl
 

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

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

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
 CallableStatement AbstractBatcher.prepareCallableStatement(String sql)
           
 PreparedStatement AbstractBatcher.prepareStatement(String sql)
           
 PreparedStatement AbstractBatcher.prepareStatement(String sql, boolean getGeneratedKeys)
           
 PreparedStatement AbstractBatcher.prepareStatement(String sql, String[] columnNames)
           
 PreparedStatement AbstractBatcher.prepareSelectStatement(String sql)
           
 PreparedStatement AbstractBatcher.prepareQueryStatement(String sql, boolean scrollable, ScrollMode scrollMode)
           
 CallableStatement AbstractBatcher.prepareCallableQueryStatement(String sql, boolean scrollable, ScrollMode scrollMode)
           
 PreparedStatement AbstractBatcher.prepareBatchStatement(String sql)
           
 CallableStatement AbstractBatcher.prepareBatchCallableStatement(String sql)
           
 void AbstractBatcher.executeBatch()
           
protected abstract  void AbstractBatcher.doExecuteBatch(PreparedStatement ps)
           
 Connection AbstractBatcher.openConnection()
           
 void AbstractBatcher.closeConnection(Connection conn)
           
 void AbstractBatcher.cancelLastQuery()
           
 Connection JDBCContext.connection()
           
 Transaction JDBCContext.getTransaction()
           
 void NonBatchingBatcher.addToBatch(Expectation expectation)
           
protected  void NonBatchingBatcher.doExecuteBatch(PreparedStatement ps)
           
 void BatchingBatcher.addToBatch(Expectation expectation)
           
protected  void BatchingBatcher.doExecuteBatch(PreparedStatement ps)
           
 PreparedStatement Batcher.prepareQueryStatement(String sql, boolean scrollable, ScrollMode scrollMode)
          Get a prepared statement for use in loading / querying.
 CallableStatement Batcher.prepareCallableQueryStatement(String sql, boolean scrollable, ScrollMode scrollMode)
          Get a prepared statement for use in loading / querying.
 PreparedStatement Batcher.prepareSelectStatement(String sql)
          Get a non-batchable prepared statement to use for selecting.
 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 Batcher.prepareStatement(String sql, String[] columnNames)
          Get a non-batchable prepared statement to use for inserting / deleting / updating.
 PreparedStatement Batcher.prepareStatement(String sql)
          Get a non-batchable prepared statement to use for inserting / deleting / updating.
 CallableStatement Batcher.prepareCallableStatement(String sql)
          Get a non-batchable callable statement to use for inserting / deleting / updating.
 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()).
 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()).
 void Batcher.addToBatch(Expectation expectation)
          Add an insert / delete / update to the current batch (might be called multiple times for single prepareBatchStatement())
 void Batcher.executeBatch()
          Execute the batch
 void Batcher.cancelLastQuery()
          Cancel the current query statement
 Connection Batcher.openConnection()
          Obtain a JDBC connection
 void Batcher.closeConnection(Connection conn)
          Dispose of the JDBC connection
 Connection ConnectionManager.getConnection()
          Retrieves the connection currently managed by this ConnectionManager.
 void Expectation.verifyOutcome(int rowCount, PreparedStatement statement, int batchPosition)
           
 int Expectation.prepare(PreparedStatement statement)
           
 int Expectations.BasicExpectation.prepare(PreparedStatement statement)
           
 int Expectations.BasicParamExpectation.prepare(PreparedStatement statement)
           
 

Uses of HibernateException in org.hibernate.jmx
 

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

Uses of HibernateException in org.hibernate.loader
 

Methods in org.hibernate.loader that throw HibernateException
protected  String Loader.applyLocks(String sql, Map lockModes, Dialect dialect)
          Append FOR UPDATE OF clause, if necessary.
protected  String Loader.preprocessSQL(String sql, QueryParameters parameters, Dialect dialect)
          Modify the SQL, adding lock hints and comments, if necessary
 Object Loader.loadSingleRow(ResultSet resultSet, SessionImplementor session, QueryParameters queryParameters, boolean returnProxies)
          Loads a single row from the result set.
 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.
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  PreparedStatement Loader.prepareQueryStatement(QueryParameters queryParameters, boolean scroll, SessionImplementor session)
          Obtain a PreparedStatement with all parameters pre-bound.
protected  int Loader.bindPositionalParameters(PreparedStatement statement, QueryParameters queryParameters, int startIndex, SessionImplementor session)
          Bind positional parameter values to the JDBC prepared statement.
protected  int Loader.bindNamedParameters(PreparedStatement statement, Map namedParams, int startIndex, SessionImplementor session)
          Bind named parameters to the JDBC prepared statement.
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.loadEntity(SessionImplementor session, Object id, Type identifierType, Object optionalObject, String optionalEntityName, Serializable optionalIdentifier, EntityPersister persister)
          Called by subclasses that load entities
protected  List Loader.loadEntity(SessionImplementor session, Object key, Object index, Type keyType, Type indexType, EntityPersister persister)
          Called by subclasses that load entities
 List Loader.loadEntityBatch(SessionImplementor session, Serializable[] ids, Type idType, Object optionalObject, String optionalEntityName, Serializable optionalId, EntityPersister persister)
          Called by wrappers that batch load entities
 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.list(SessionImplementor session, QueryParameters queryParameters, Set querySpaces, Type[] resultTypes)
          Return the query results, using the query cache, called by subclasses that implement cacheable queries
protected  List Loader.doList(SessionImplementor session, QueryParameters queryParameters)
          Actually execute a query, ignoring the query cache
protected  void Loader.checkScrollability()
          Check whether the current loader can support returning ScrollableResults.
protected  ScrollableResults Loader.scroll(QueryParameters queryParameters, Type[] returnTypes, HolderInstantiator holderInstantiator, SessionImplementor session)
          Return the query results, as an instance of ScrollableResults
 

Uses of HibernateException in org.hibernate.loader.collection
 

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

Uses of HibernateException in org.hibernate.loader.criteria
 

Methods in org.hibernate.loader.criteria that throw HibernateException
 ScrollableResults CriteriaLoader.scroll(SessionImplementor session, ScrollMode scrollMode)
           
 List CriteriaLoader.list(SessionImplementor session)
           
protected  Object CriteriaLoader.getResultColumnOrRow(Object[] row, ResultTransformer transformer, ResultSet rs, SessionImplementor session)
           
 String[] CriteriaQueryTranslator.getColumnsUsingProjection(Criteria subcriteria, String propertyName)
          Get the names of the columns constrained by this criterion.
 Type CriteriaQueryTranslator.getTypeUsingProjection(Criteria subcriteria, String propertyName)
           
 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.
 

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

Uses of HibernateException in org.hibernate.loader.custom
 

Methods in org.hibernate.loader.custom that throw HibernateException
 List CustomLoader.list(SessionImplementor session, QueryParameters queryParameters)
           
 ScrollableResults CustomLoader.scroll(QueryParameters queryParameters, SessionImplementor session)
           
protected  Object CustomLoader.getResultColumnOrRow(Object[] row, ResultTransformer transformer, ResultSet rs, SessionImplementor session)
           
 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)
           
 

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
 Object EntityLoader.loadByUniqueKey(SessionImplementor session, Object key)
           
 Object AbstractEntityLoader.load(Serializable id, Object optionalObject, SessionImplementor session)
           
protected  Object AbstractEntityLoader.load(SessionImplementor session, Object id, Object optionalObject, Serializable optionalId)
           
protected  Object AbstractEntityLoader.getResultColumnOrRow(Object[] row, ResultTransformer transformer, ResultSet rs, SessionImplementor session)
           
 Object UniqueEntityLoader.load(Serializable id, Object optionalObject, SessionImplementor session)
          Load an entity instance.
 Object BatchingEntityLoader.load(Serializable id, Object optionalObject, SessionImplementor session)
           
 Object CollectionElementLoader.loadElement(SessionImplementor session, Object key, Object index)
           
protected  Object CollectionElementLoader.getResultColumnOrRow(Object[] row, ResultTransformer transformer, ResultSet rs, SessionImplementor session)
           
 

Uses of HibernateException in org.hibernate.loader.hql
 

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

Uses of HibernateException in org.hibernate.mapping
 

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

Uses of HibernateException in org.hibernate.metadata
 

Methods in org.hibernate.metadata that throw HibernateException
 Type ClassMetadata.getPropertyType(String propertyName)
          Get the type of a particular (named) property
 Object[] ClassMetadata.getPropertyValuesToInsert(Object entity, Map mergeMap, SessionImplementor session)
          Return the values of the mapped properties of the object
 Object ClassMetadata.instantiate(Serializable id, EntityMode entityMode)
          Create a class instance initialized with the given identifier
 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.
 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
 Serializable ClassMetadata.getIdentifier(Object entity, EntityMode entityMode)
          Get the identifier of an instance (throw an exception if no identifier property)
 void ClassMetadata.setIdentifier(Object object, Serializable id, EntityMode entityMode)
          Set the identifier of an instance (or do nothing if no identifier property)
 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)
 

Uses of HibernateException in org.hibernate.persister
 

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

Uses of HibernateException in org.hibernate.persister.collection
 

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

Uses of HibernateException in org.hibernate.persister.entity
 

Methods in org.hibernate.persister.entity that throw HibernateException
 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[] 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 NamedQueryLoader.load(Serializable id, Object optionalObject, SessionImplementor session)
           
 Object AbstractEntityPersister.initializeLazyProperty(String fieldName, Object entity, SessionImplementor session)
           
 Object[] AbstractEntityPersister.getDatabaseSnapshot(Serializable id, SessionImplementor session)
           
 Object AbstractEntityPersister.getCurrentVersion(Serializable id, SessionImplementor session)
          Retrieve the version number
 void AbstractEntityPersister.lock(Serializable id, Object version, Object object, LockMode lockMode, SessionImplementor session)
           
 Object AbstractEntityPersister.loadByUniqueKey(String propertyName, Object uniqueKey, SessionImplementor session)
           
protected  boolean AbstractEntityPersister.check(int rows, Serializable id, int tableNumber, Expectation expectation, PreparedStatement statement)
           
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
 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.
protected  Serializable AbstractEntityPersister.insert(Object[] fields, boolean[] notNull, String sql, Object object, SessionImplementor session)
          Perform an SQL INSERT, and then retrieve a generated identifier.
protected  void AbstractEntityPersister.insert(Serializable id, Object[] fields, boolean[] notNull, int j, String sql, Object object, SessionImplementor session)
          Perform an SQL INSERT.
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
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.delete(Serializable id, Object version, int j, Object object, String sql, SessionImplementor session, Object[] loadedState)
          Perform an SQL DELETE
 void AbstractEntityPersister.update(Serializable id, Object[] fields, int[] dirtyFields, boolean hasDirtyCollection, Object[] oldFields, Object oldVersion, Object object, Object rowId, SessionImplementor session)
          Update an object
 Serializable AbstractEntityPersister.insert(Object[] fields, Object object, SessionImplementor session)
           
 void AbstractEntityPersister.insert(Serializable id, Object[] fields, Object object, SessionImplementor session)
           
 void AbstractEntityPersister.delete(Serializable id, Object version, Object object, SessionImplementor session)
          Delete an object
 Object AbstractEntityPersister.load(Serializable id, Object optionalObject, LockMode lockMode, SessionImplementor session)
          Load an instance using either the forUpdateLoader or the outer joining loader, depending upon the value of the lock parameter
 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.
 Boolean AbstractEntityPersister.isTransient(Object entity, SessionImplementor session)
           
 IdentifierGenerator AbstractEntityPersister.getIdentifierGenerator()
           
 Object AbstractEntityPersister.createProxy(Serializable id, SessionImplementor session)
           
 void AbstractEntityPersister.setPropertyValues(Object object, Object[] values, EntityMode entityMode)
           
 void AbstractEntityPersister.setPropertyValue(Object object, int i, Object value, EntityMode entityMode)
           
 Object[] AbstractEntityPersister.getPropertyValues(Object object, EntityMode entityMode)
           
 Object AbstractEntityPersister.getPropertyValue(Object object, int i, EntityMode entityMode)
           
 Object AbstractEntityPersister.getPropertyValue(Object object, String propertyName, EntityMode entityMode)
           
 Serializable AbstractEntityPersister.getIdentifier(Object object, EntityMode entityMode)
           
 void AbstractEntityPersister.setIdentifier(Object object, Serializable id, EntityMode entityMode)
           
 Object AbstractEntityPersister.getVersion(Object object, EntityMode entityMode)
           
 Object AbstractEntityPersister.instantiate(Serializable id, EntityMode entityMode)
           
 Object[] AbstractEntityPersister.getPropertyValuesToInsert(Object object, Map mergeMap, SessionImplementor session)
           
 Object[] AbstractEntityPersister.getNaturalIdentifierSnapshot(Serializable id, SessionImplementor session)
           
 void AbstractEntityPersister.setPropertyValue(Object object, String propertyName, Object value, EntityMode entityMode)
           
 Object EntityPersister.load(Serializable id, Object optionalObject, LockMode lockMode, SessionImplementor session)
          Load an instance of the persistent class.
 void EntityPersister.lock(Serializable id, Object version, Object object, LockMode lockMode, SessionImplementor session)
          Do a version check (optional operation)
 void EntityPersister.insert(Serializable id, Object[] fields, Object object, SessionImplementor session)
          Persist an instance
 Serializable EntityPersister.insert(Object[] fields, Object object, SessionImplementor session)
          Persist an instance, using a natively generated identifier (optional operation)
 void EntityPersister.delete(Serializable id, Object version, Object object, SessionImplementor session)
          Delete a persistent instance
 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
 Object[] EntityPersister.getDatabaseSnapshot(Serializable id, SessionImplementor session)
          Get the current database state of the object, in a "hydrated" form, without resolving identifiers
 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 EntityPersister.forceVersionIncrement(Serializable id, Object currentVersion, SessionImplementor session)
           
 Object EntityPersister.createProxy(Serializable id, SessionImplementor session)
          Create a new proxy instance
 Boolean EntityPersister.isTransient(Object object, SessionImplementor session)
          Is this a new transient instance?
 Object[] EntityPersister.getPropertyValuesToInsert(Object object, Map mergeMap, SessionImplementor session)
          Return the values of the insertable properties of the object (including backrefs)
 void EntityPersister.setPropertyValues(Object object, Object[] values, EntityMode entityMode)
          Set the given values to the mapped properties of the given object
 void EntityPersister.setPropertyValue(Object object, int i, Object value, EntityMode entityMode)
          Set the value of a particular property
 Object[] EntityPersister.getPropertyValues(Object object, EntityMode entityMode)
          Return the (loaded) values of the mapped properties of the object (not including backrefs)
 Object EntityPersister.getPropertyValue(Object object, int i, EntityMode entityMode)
          Get the value of a particular property
 Object EntityPersister.getPropertyValue(Object object, String propertyName, EntityMode entityMode)
          Get the value of a particular property
 Serializable EntityPersister.getIdentifier(Object object, EntityMode entityMode)
          Get the identifier of an instance (throw an exception if no identifier property)
 void EntityPersister.setIdentifier(Object object, Serializable id, EntityMode entityMode)
          Set the identifier of an instance (or do nothing if no identifier property)
 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 EntityPersister.instantiate(Serializable id, EntityMode entityMode)
          Create a class instance initialized with the given identifier
 

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

Uses of HibernateException in org.hibernate.pretty
 

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

Uses of HibernateException in org.hibernate.property
 

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

Uses of HibernateException in org.hibernate.proxy
 

Methods in org.hibernate.proxy that throw HibernateException
 void ProxyFactory.postInstantiate(String entityName, Class persistentClass, Set interfaces, Method getIdentifierMethod, Method setIdentifierMethod, AbstractComponentType componentIdType)
          Called immediately after instantiation of this factory.
 HibernateProxy ProxyFactory.getProxy(Serializable id, SessionImplementor session)
          Create a new proxy instance
 void AbstractLazyInitializer.setSession(SessionImplementor s)
          Associate the proxy with the given session.

Care should be given to make certain that the proxy is added to the session's persistence context as well to maintain the symetry of the association. That must be done seperately as this method simply sets an internal reference. We do also check that if there is already an associated session that the proxy reference was removed from that previous session's persistence contet.

 void AbstractLazyInitializer.initialize()
          Initialize the proxy, fetching the target entity if necessary.
 Object AbstractLazyInitializer.getImplementation(SessionImplementor s)
          Return the underlying persistent object in the given Session, or null, do not initialize the proxy
 void LazyInitializer.initialize()
          Initialize the proxy, fetching the target entity if necessary.
 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.
 void LazyInitializer.setSession(SessionImplementor session)
          Associate the proxy with the given session.
 

Uses of HibernateException in org.hibernate.proxy.dom4j
 

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

Uses of HibernateException in org.hibernate.proxy.map
 

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

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

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

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

Methods in org.hibernate.proxy.pojo.javassist that throw HibernateException
static HibernateProxy JavassistLazyInitializer.getProxy(String entityName, Class persistentClass, Class[] interfaces, Method getIdentifierMethod, Method setIdentifierMethod, AbstractComponentType componentIdType, Serializable id, SessionImplementor session)
           
static HibernateProxy JavassistLazyInitializer.getProxy(Class factory, 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)
           
 HibernateProxy JavassistProxyFactory.getProxy(Serializable id, SessionImplementor session)
           
 

Uses of HibernateException in org.hibernate.secure
 

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

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

Uses of HibernateException in org.hibernate.transaction
 

Methods in org.hibernate.transaction that throw HibernateException
 void CMTTransactionFactory.configure(Properties props)
           
 Transaction CMTTransactionFactory.createTransaction(JDBCContext jdbcContext, TransactionFactory.Context transactionContext)
           
 TransactionManager WebSphereTransactionManagerLookup.getTransactionManager(Properties props)
           
 TransactionManager TransactionManagerLookup.getTransactionManager(Properties props)
          Obtain the JTA TransactionManager
static TransactionFactory TransactionFactoryFactory.buildTransactionFactory(Properties transactionProps)
          Obtain a TransactionFactory with the transaction handling strategy specified by the given Properties.
 TransactionManager JOTMTransactionManagerLookup.getTransactionManager(Properties props)
           
static TransactionManager TransactionManagerLookupFactory.getTransactionManager(Properties props)
           
static TransactionManagerLookup TransactionManagerLookupFactory.getTransactionManagerLookup(Properties props)
           
 void JTATransactionFactory.configure(Properties props)
          Configure this transaction factory.
 Transaction JTATransactionFactory.createTransaction(JDBCContext jdbcContext, TransactionFactory.Context transactionContext)
          Begin a transaction and return the associated Transaction instance.
 void CMTTransaction.begin()
           
 void CMTTransaction.commit()
           
 void CMTTransaction.rollback()
           
 void CMTTransaction.registerSynchronization(Synchronization sync)
           
 TransactionManager JOnASTransactionManagerLookup.getTransactionManager(Properties props)
           
 Transaction JDBCTransactionFactory.createTransaction(JDBCContext jdbcContext, TransactionFactory.Context transactionContext)
           
 void JDBCTransactionFactory.configure(Properties props)
           
 void JDBCTransaction.begin()
           
 void JDBCTransaction.commit()
           
 void JDBCTransaction.rollback()
           
 void JDBCTransaction.registerSynchronization(Synchronization sync)
           
 Transaction TransactionFactory.createTransaction(JDBCContext jdbcContext, TransactionFactory.Context context)
          Begin a transaction and return the associated Transaction instance.
 void TransactionFactory.configure(Properties props)
          Configure from the given properties.
 void JTATransaction.begin()
           
 void JTATransaction.commit()
           
 void JTATransaction.rollback()
           
 void JTATransaction.registerSynchronization(Synchronization sync)
           
 TransactionManager JNDITransactionManagerLookup.getTransactionManager(Properties props)
           
 

Uses of HibernateException in org.hibernate.tuple
 

Methods in org.hibernate.tuple that throw HibernateException
 Object[] Tuplizer.getPropertyValues(Object entity)
          Extract the current values contained on the given entity.
 void Tuplizer.setPropertyValues(Object entity, Object[] values)
          Inject the given values into the given entity.
 Object Tuplizer.getPropertyValue(Object entity, int i)
          Extract the value of a particular property from the given entity.
 Object Tuplizer.instantiate()
          Generate a new, empty entity.
 

Uses of HibernateException in org.hibernate.tuple.component
 

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

Uses of HibernateException in org.hibernate.tuple.entity
 

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

Uses of HibernateException in org.hibernate.type
 

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

Methods in org.hibernate.type that throw HibernateException
 PersistentCollection IdentifierBagType.instantiate(SessionImplementor session, CollectionPersister persister, Serializable key)
           
 Object CalendarDateType.get(ResultSet rs, String name)
           
 void CalendarDateType.set(PreparedStatement st, Object value, int index)
           
 String CalendarDateType.toString(Object value)
           
 Object CalendarDateType.fromStringValue(String xml)
           
 Object[] AbstractComponentType.getPropertyValues(Object component, SessionImplementor session)
          Get the values of the component properties of a component instance
 Object[] AbstractComponentType.getPropertyValues(Object component, EntityMode entityMode)
          Optional operation
 void AbstractComponentType.setPropertyValues(Object component, Object[] values, EntityMode entityMode)
          Optional operation
 Object AbstractComponentType.getPropertyValue(Object component, int i, SessionImplementor session)
           
 Object CurrencyType.get(ResultSet rs, String name)
           
 void CurrencyType.set(PreparedStatement st, Object value, int index)
           
 String CurrencyType.toString(Object value)
           
 Object CurrencyType.fromStringValue(String xml)
           
 Object BigIntegerType.get(ResultSet rs, String name)
           
 void BigIntegerType.set(PreparedStatement st, Object value, int index)
           
 String BigIntegerType.toString(Object value)
           
 Object DateType.fromStringValue(String xml)
           
 Serializable AbstractType.disassemble(Object value, SessionImplementor session, Object owner)
           
 Object AbstractType.assemble(Serializable cached, SessionImplementor session, Object owner)
           
 boolean AbstractType.isDirty(Object old, Object current, SessionImplementor session)
           
 Object AbstractType.hydrate(ResultSet rs, String[] names, SessionImplementor session, Object owner)
           
 Object AbstractType.resolve(Object value, SessionImplementor session, Object owner)
           
 Object AbstractType.semiResolve(Object value, SessionImplementor session, Object owner)
           
 boolean AbstractType.isModified(Object old, Object current, boolean[] checkable, SessionImplementor session)
           
 boolean AbstractType.isSame(Object x, Object y, EntityMode entityMode)
           
 Object AbstractType.replace(Object original, Object target, SessionImplementor session, Object owner, Map copyCache, ForeignKeyDirection foreignKeyDirection)
           
 Object ClassType.get(ResultSet rs, String name)
           
 void ClassType.set(PreparedStatement st, Object value, int index)
           
 String ClassType.toString(Object value)
           
 Object ClassType.fromStringValue(String xml)
           
 Object EmbeddedComponentType.instantiate(Object parent, SessionImplementor session)
           
 Object OneToOneType.hydrate(ResultSet rs, String[] names, SessionImplementor session, Object owner)
           
 Serializable OneToOneType.disassemble(Object value, SessionImplementor session, Object owner)
           
 Object OneToOneType.assemble(Serializable oid, SessionImplementor session, Object owner)
           
 boolean ComponentType.isSame(Object x, Object y, EntityMode entityMode)
           
 boolean ComponentType.isEqual(Object x, Object y, EntityMode entityMode)
           
 boolean ComponentType.isEqual(Object x, Object y, EntityMode entityMode, SessionFactoryImplementor factory)
           
 boolean ComponentType.isDirty(Object x, Object y, SessionImplementor session)
           
 boolean ComponentType.isDirty(Object x, Object y, boolean[] checkable, SessionImplementor session)
           
 boolean ComponentType.isModified(Object old, Object current, boolean[] checkable, SessionImplementor session)
           
 Object ComponentType.nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)
           
 void ComponentType.nullSafeSet(PreparedStatement st, Object value, int begin, SessionImplementor session)
           
 void ComponentType.nullSafeSet(PreparedStatement st, Object value, int begin, boolean[] settable, SessionImplementor session)
           
 Object ComponentType.nullSafeGet(ResultSet rs, String name, SessionImplementor session, Object owner)
           
 Object ComponentType.getPropertyValue(Object component, int i, SessionImplementor session)
           
 Object ComponentType.getPropertyValue(Object component, int i, EntityMode entityMode)
           
 Object[] ComponentType.getPropertyValues(Object component, SessionImplementor session)
           
 Object[] ComponentType.getPropertyValues(Object component, EntityMode entityMode)
           
 void ComponentType.