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.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.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.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.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.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.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.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 InstantiationException
          Thrown if Hibernate can't instantiate an entity or component class at runtime.
 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 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 SessionException
          Thrown when the user calls a method of a Session that is in an inappropropriate state (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 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 Transaction.commit()
          Flush the associated Session and end the unit of work.
 void Transaction.rollback()
          Force the underlying transaction to roll back.
 boolean Transaction.wasRolledBack()
          Was this transaction rolled back or set to rollback only?
 boolean Transaction.wasCommitted()
          Check if this transaction was successfully committed.
 boolean Transaction.isActive()
          Is this transaction still active?
 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, where "current" is maintained in relation to the current JTA transaction; if a Session is not already associated with the current JTA transaction, a new Session will be opened and it will be associated with that JTA transaction.
 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.
 void Session.flush()
          Force the Session to flush.
 Connection Session.connection()
          Get the JDBC connection.
 Connection Session.disconnect()
          Disconnect the Session from the current JDBC connection.
 void Session.reconnect()
          Obtain a new JDBC connection.
 void Session.reconnect(Connection connection)
          Reconnect to the given JDBC connection.
 Connection Session.close()
          End the Session by disconnecting from the JDBC connection and cleaning up.
 void Session.cancelQuery()
          Cancel execution of the current query.
 boolean Session.isDirty()
          Does this Session contain any changes which must be synchronized with the database? Would any SQL be executed if we flushed this session?
 Serializable Session.getIdentifier(Object object)
          Return the identifier of an entity instance cached by the Session, or throw an exception if the instance is transient or associated with a different 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.
 void Session.save(Object object, Serializable id)
          Persist the given transient instance, using the given identifier.
 Serializable Session.save(String entityName, Object object)
          Persist the given transient instance, first assigning a generated identifier.
 void Session.save(String entityName, Object object, Serializable id)
          Persist the given transient instance, using the given identifier.
 void Session.saveOrUpdate(Object object)
          Either save() or update() the given instance, depending upon the value of its identifier property.
 void Session.saveOrUpdate(String entityName, Object object)
          Either save() or update() the given instance, depending upon the value of its identifier property.
 void Session.update(Object object)
          Update the persistent instance with the identifier of the given detached instance.
 void Session.update(Object object, Serializable id)
          Update the persistent state associated with the given identifier.
 void Session.update(String entityName, Object object)
          Update the persistent instance with the identifier of the given detached instance.
 void Session.update(String entityName, Object object, Serializable id)
          Update the persistent state associated with the given identifier.
 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.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 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
 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).
 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, guessing the Hibernate type from the class of the given object.
 Query Query.setParameter(String name, Object val)
          Bind a value to a named query parameter, guessing the Hibernate type from the class of the given object.
 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, guessing the Hibernate type from the class of the first object in the collection.
 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, guessing the Hibernate type from the class of the first object in the array.
 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.
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.
 void Filter.validate()
          Perform validation of the filter state.
 Criteria Criteria.setFetchMode(String associationPath, FetchMode mode)
          Specify an association fetching strategy for a one-to-many, many-to-one or one-to-one association, or for a collection of values.
 Criteria Criteria.createAlias(String associationPath, String alias)
          Join an association, assigning an alias to the joined entity
 Criteria Criteria.createCriteria(String associationPath)
          Create a new Criteria, "rooted" at the associated entity
 Criteria Criteria.createCriteria(String associationPath, String alias)
          Create a new Criteria, "rooted" at the associated entity, assigning the given alias
 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.
 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 Executable.beforeExecutions()
          Called before executing any actions
 void Executable.execute()
          Execute this action
 void Executable.afterTransactionCompletion(boolean success)
          Called after the transaction completes
 void EntityUpdateAction.execute()
           
 void EntityInsertAction.execute()
           
 void EntityInsertAction.afterTransactionCompletion(boolean success)
           
 void EntityIdentityInsertAction.execute()
           
 void EntityIdentityInsertAction.afterTransactionCompletion(boolean success)
           
 void EntityDeleteAction.execute()
           
 void EntityDeleteAction.afterTransactionCompletion(boolean success)
           
 void CollectionUpdateAction.execute()
           
 void CollectionRemoveAction.execute()
           
 void CollectionRecreateAction.execute()
           
 

Constructors in org.hibernate.action that throw HibernateException
EntityUpdateAction(Serializable id, Object[] fields, int[] dirtyProperties, boolean hasDirtyCollection, Object[] oldFields, Object lastVersion, Object nextVersion, Object instance, Object[] updatedState, 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)
           
 

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

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, SessionImplementor session)
           
 

Constructors in org.hibernate.cache.entry that throw HibernateException
CacheEntry(Object[] state, EntityPersister persister, boolean unfetched, 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
 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
 

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 org.hibernate.Session#merge(Object)
 Object Session.saveOrUpdateCopy(Object object, Serializable id)
          Deprecated. use org.hibernate.Session#merge(Object, java.io.Serializable)
 Object Session.saveOrUpdateCopy(String entityName, Object object)
          Deprecated. use org.hibernate.Session#merge(String, Object)
 Object Session.saveOrUpdateCopy(String entityName, Object object, Serializable id)
          Deprecated. use org.hibernate.Session#merge(String, Object, java.io.Serializable)
 List Session.find(String query)
          Deprecated. use createQuery()
 List Session.find(String query, Object value, Type type)
          Deprecated. use createQuery() Bind a value to a "?" parameter in the query string.
 List Session.find(String query, Object[] values, Type[] types)
          Deprecated. use createQuery() Binding an array of values to "?" parameters in the query string.
 Iterator Session.iterate(String query)
          Deprecated. use createQuery()
 Iterator Session.iterate(String query, Object value, Type type)
          Deprecated. use createQuery()
 Iterator Session.iterate(String query, Object[] values, Type[] types)
          Deprecated. use createQuery()
 Collection Session.filter(Object collection, String filter)
          Deprecated. use createQuery()
 Collection Session.filter(Object collection, String filter, Object value, Type type)
          Deprecated. use createQuery()
 Collection Session.filter(Object collection, String filter, Object[] values, Type[] types)
          Deprecated. use createQuery()
 int Session.delete(String query)
          Deprecated. use createQuery()
 int Session.delete(String query, Object value, Type type)
          Deprecated. use createQuery()
 int Session.delete(String query, Object[] values, Type[] types)
          Deprecated. use createQuery()
 

Uses of HibernateException in org.hibernate.collection
 

Methods in org.hibernate.collection that throw HibernateException
protected  Serializable PersistentSortedSet.snapshot(BasicCollectionPersister persister, EntityMode entityMode)
           
protected  Serializable PersistentSortedMap.snapshot(BasicCollectionPersister persister, EntityMode entityMode)
           
protected  Serializable PersistentSet.snapshot(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)
           
 void PersistentMapElementHolder.initializeFromCache(CollectionPersister persister, Serializable disassembled, Object owner)
           
 Serializable PersistentMapElementHolder.disassemble(CollectionPersister persister)
           
protected  Serializable PersistentMap.snapshot(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 PersistentListElementHolder.initializeFromCache(CollectionPersister persister, Serializable disassembled, Object owner)
           
 Serializable PersistentListElementHolder.disassemble(CollectionPersister persister)
           
protected  Serializable PersistentList.snapshot(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)
           
protected  Serializable PersistentIndexedElementHolder.snapshot(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)
           
 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)
           
protected  Serializable PersistentIdentifierBag.snapshot(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 PersistentElementHolder.snapshot(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)
           
 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, or null if no persister is passed
 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)
           
protected  Serializable PersistentBag.snapshot(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)
           
protected  Serializable PersistentArrayHolder.snapshot(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)
           
 boolean AbstractPersistentCollection.setCurrentSession(SessionImplementor session)
          Associate the collection with the given session.
 Serializable AbstractPersistentCollection.getSnapshot(CollectionPersister persister)
          Return a new snapshot of the current state of the collection, or null if no persister is passed
protected abstract  Serializable AbstractPersistentCollection.snapshot(CollectionPersister persister)
          Return a new snapshot of the current state
 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)
           
 

Constructors in org.hibernate.collection that throw HibernateException
PersistentSortedSet(SessionImplementor session, CollectionPersister persister, Comparator comparator, Serializable disassembled, Object owner)
           
PersistentSortedMap(SessionImplementor session, CollectionPersister persister, Comparator comparator, Serializable disassembled, Object owner)
           
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 UserSuppliedConnectionProvider.configure(Properties props)
           
 void ProxoolConnectionProvider.configure(Properties props)
          Initialize the connection provider from given properties.
 void ProxoolConnectionProvider.close()
          Release all resources held by this provider.
 void DriverManagerConnectionProvider.configure(Properties props)
           
 void DatasourceConnectionProvider.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.
 void ConnectionProvider.configure(Properties props)
          Initialize the connection provider from given properties.
 void ConnectionProvider.close()
          Release all resources held by this provider.
 void C3P0ConnectionProvider.configure(Properties props)
           
 

Uses of HibernateException in org.hibernate.criterion
 

Methods in org.hibernate.criterion that throw HibernateException
 String SubqueryExpression.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)
           
 TypedValue[] SubqueryExpression.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)
           
 String SQLCriterion.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)
           
 TypedValue[] SQLCriterion.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)
           
 String SizeExpression.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)
           
 TypedValue[] SizeExpression.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)
           
 TypedValue[] SimpleSubqueryExpression.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)
           
 Type[] SimpleProjection.getTypes(String alias, Criteria criteria, CriteriaQuery criteriaQuery)
           
 String SimpleProjection.toGroupSqlString(Criteria criteria, CriteriaQuery criteriaQuery)
           
 String SimpleExpression.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)
           
 TypedValue[] SimpleExpression.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)
           
 Type[] RowCountProjection.getTypes(Criteria criteria, CriteriaQuery criteriaQuery)
           
 String RowCountProjection.toSqlString(Criteria criteria, int position, 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 PropertyExpression.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)
           
 TypedValue[] PropertyExpression.getTypedValues(Criteria criteria, 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 Projection.toSqlString(Criteria criteria, int position, CriteriaQuery criteriaQuery)
          Render the SQL fragment
 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)
          Return types returned by the rendered SQL fragment
 Type[] Projection.getTypes(String alias, Criteria criteria, CriteriaQuery criteriaQuery)
          Return types for a particular user-visible alias
 String Order.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)
          Render the SQL fragment
 String NullExpression.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)
           
 TypedValue[] NullExpression.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)
           
 String NotNullExpression.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)
           
 TypedValue[] NotNullExpression.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)
           
 String NotExpression.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)
           
 TypedValue[] NotExpression.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)
           
 TypedValue[] NaturalIdentifier.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)
           
 String NaturalIdentifier.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)
           
 TypedValue[] LogicalExpression.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)
           
 String LogicalExpression.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)
           
 TypedValue[] Junction.getTypedValues(Criteria crit, CriteriaQuery criteriaQuery)
           
 String Junction.toSqlString(Criteria crit, CriteriaQuery criteriaQuery)
           
 String InExpression.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)
           
 TypedValue[] InExpression.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)
           
 String IlikeExpression.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)
           
 TypedValue[] IlikeExpression.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)
           
 String IdentifierEqExpression.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)
           
 TypedValue[] IdentifierEqExpression.getTypedValues(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 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)
           
 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)
           
 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
 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.
 Type[] CountProjection.getTypes(Criteria criteria, CriteriaQuery criteriaQuery)
           
 String CountProjection.toSqlString(Criteria criteria, int position, CriteriaQuery criteriaQuery)
           
 String BetweenExpression.toSqlString(Criteria criteria, CriteriaQuery criteriaQuery)
           
 TypedValue[] BetweenExpression.getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery)
           
 Type[] AvgProjection.getTypes(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)
           
 Type[] AggregateProjection.getTypes(Criteria criteria, CriteriaQuery criteriaQuery)
           
 String AggregateProjection.toSqlString(Criteria criteria, int loc, 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)
           
 

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 Dialect.getTypeName(int code)
          Get the name of the database type associated with the given java.sql.Types typecode.
 String Dialect.getTypeName(int code, int length, int precision, int scale)
          Get the name of the database type associated with the given java.sql.Types typecode.
static Dialect Dialect.getDialect()
          Get the Dialect specified by the current System properties.
static Dialect Dialect.getDialect(Properties props)
          Get the Dialect specified by the given properties or system properties.
 

Uses of HibernateException in org.hibernate.engine
 

Methods in org.hibernate.engine that throw HibernateException
static Object Versioning.getVersion(Object[] fields, EntityPersister persister)
          Get the version number of the given instance state snapshot
static void TwoPhaseLoad.postHydrate(EntityPersister persister, Serializable id, Object[] values, Object rowId, Object object, LockMode lockMode, 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
 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
 void SessionImplementor.merge(String entityName, Object object, Map copiedAlready)
          Cascade merge an entity instance
 void SessionImplementor.persist(String entityName, Object object, Map createdAlready)
          Cascade persist an entity instance
 void SessionImplementor.saveOrUpdateCopy(String entityName, Object object, Map copiedAlready)
          Cascade copy an entity instance
 void SessionImplementor.forceFlush(EntityEntry e)
          Force an immediate flush
 Object SessionImplementor.instantiate(EntityPersister persister, Serializable id)
          Instantiate an entity instance, using either an interceptor, or the given persister
 int SessionImplementor.executeUpdate(String query, QueryParameters queryParameters)
          Execute a HQL update or delete query
 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
 void QueryParameters.traceParameters(SessionFactoryImplementor factory)
           
 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.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(Serializable id, EntityPersister persister, 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(PersistentCollection collection, CollectionPersister persister)
          Add a new collection (ie.
 void PersistenceContext.addInitializedDetachedCollection(PersistentCollection collection, CollectionSnapshot cs, EntityMode em)
          add an (initialized) collection that was created by another session and passed into update() (ie.
 CollectionEntry PersistenceContext.addInitializedCollection(PersistentCollection collection, CollectionPersister persister, Serializable id, EntityMode em)
          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)
 void Nullability.checkNullability(Object[] values, EntityPersister persister, boolean isUpdate)
          Check nullability of the class persister properties
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
static void Collections.processUnreachableCollection(PersistentCollection coll, SessionImplementor session)
          record the fact that this collection was dereferenced
static void Collections.processReachableCollection(PersistentCollection coll, Type type, Object entity, SessionImplementor session)
          Initialize the role of the collection.
 PersistentCollection CollectionLoadContext.getLoadingCollection(CollectionPersister persister, Serializable key, Object resultSetId, EntityMode em)
          Retrieve a collection that is in the process of being loaded, instantiating a new collection if there is nothing for the given id, or returning null if the collection with the given id is already fully loaded in the session
 void CollectionLoadContext.endLoadingCollections(CollectionPersister persister, Object resultSetId, SessionImplementor session)
          Finish the process of loading collections for a particular result set
 void CollectionEntry.preFlush(PersistentCollection collection)
           
 void CollectionEntry.postInitialize(PersistentCollection collection)
           
 boolean CollectionEntry.postFlush(PersistentCollection collection)
          Called after a successful flush, returning true if the collection has been dereferenced, and the entry can be removed.
 void CollectionEntry.initSnapshot(PersistentCollection collection, CollectionPersister persister)
           
 Collection CollectionEntry.getOrphans(String entityName, PersistentCollection coll)
          Get the collection orphans (entities which were removed from the collection)
static void Cascades.cascade(SessionImplementor session, EntityPersister persister, Object parent, Cascades.CascadingAction action, int cascadeTo)
          Cascade an action from the parent object to all its children
static void Cascades.cascade(SessionImplementor session, EntityPersister persister, Object parent, Cascades.CascadingAction action, int cascadeTo, Object anything)
          Cascade an action from the parent object to all its children
 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.
 

Uses of HibernateException in org.hibernate.event
 

Methods in org.hibernate.event that throw HibernateException
 void SessionEventListenerConfig.validate()
          Checks to ensure the SessionEventListenerConfig is fully configured (basically, that none of the listeners is null).
 Serializable SaveOrUpdateEventListener.onSaveOrUpdate(SaveOrUpdateEvent event)
          Handle the given update event.
 void ReplicateEventListener.onReplicate(ReplicateEvent event)
          Handle the given replicate event.
 void RefreshEventListener.onRefresh(RefreshEvent event)
          Handle the given refresh event.
 void PersistEventListener.onPersist(PersistEvent event)
          Handle the given create event.
 void PersistEventListener.onPersist(PersistEvent event, Map createdAlready)
          Handle the given create event.
 Object MergeEventListener.onMerge(MergeEvent event)
          Handle the given merge event.
 Object MergeEventListener.onMerge(MergeEvent event, Map copiedAlready)
          Handle the given merge event.
 void LockEventListener.onLock(LockEvent event)
          Handle the given lock event.
 Object LoadEventListener.onLoad(LoadEvent event, LoadEventListener.LoadType loadType)
          Handle the given load event.
 void InitializeCollectionEventListener.onInitializeCollection(InitializeCollectionEvent event)
           
 void FlushEventListener.onFlush(FlushEvent event)
          Handle the given flush event.
 void FlushEntityEventListener.onFlushEntity(FlushEntityEvent event)
           
 void EvictEventListener.onEvict(EvictEvent event)
          Handle the given evict event.
 boolean DirtyCheckEventListener.onDirtyCheck(DirtyCheckEvent event)
          Handle the given dirty-check event.
 void DeleteEventListener.onDelete(DeleteEvent event)
          Handle the given delete event.
 boolean AutoFlushEventListener.onAutoFlush(AutoFlushEvent event)
          Handle the given auto-flush event.
 

Uses of HibernateException in org.hibernate.event.def
 

Methods in org.hibernate.event.def that throw HibernateException
 void ReattachVisitor.removeCollection(CollectionPersister role, Serializable id, SessionImplementor source)
          Schedules a collection for deletion.
protected  void ProxyVisitor.reattachCollection(PersistentCollection collection, CollectionSnapshot snapshot)
          Reattach a detached (disassociated) initialized or uninitialized collection wrapper, using a snapshot carried with the collection wrapper
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
 Serializable DefaultSaveOrUpdateEventListener.onSaveOrUpdate(SaveOrUpdateEvent event)
          Handle the given update event.
protected  Serializable DefaultSaveOrUpdateEventListener.entityIsPersistent(SaveOrUpdateEvent event)
           
protected  Serializable DefaultSaveOrUpdateEventListener.entityIsTransient(SaveOrUpdateEvent event)
          Handle the given save event.
protected  void DefaultSaveOrUpdateEventListener.entityIsDetached(SaveOrUpdateEvent event)
          Handle the given update event.
protected  Serializable DefaultSaveOrUpdateEventListener.getUpdateId(Object entity, EntityPersister persister, Serializable requestedId, EntityMode entityMode)
           
protected  void DefaultSaveOrUpdateEventListener.performUpdate(SaveOrUpdateEvent event, Object entity, EntityPersister persister)
           
 void DefaultReplicateEventListener.onReplicate(ReplicateEvent event)
          Handle the given replicate event.
 void DefaultRefreshEventListener.onRefresh(RefreshEvent event)
          Handle the given refresh 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.
 Object DefaultMergeEventListener.onMerge(MergeEvent event)
          Handle the given merge event.
 Object DefaultMergeEventListener.onMerge(MergeEvent event, Map copyCache)
          Handle the given merge event.
 void DefaultLockEventListener.onLock(LockEvent event)
          Handle the given lock event.
 Object 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.
 void DefaultInitializeCollectionEventListener.onInitializeCollection(InitializeCollectionEvent event)
          called by a collection that wants to initialize itself
 void DefaultFlushEventListener.onFlush(FlushEvent event)
          Handle the given flush event.
 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 DefaultEvictEventListener.onEvict(EvictEvent event)
          Handle the given evict event.
protected  void DefaultEvictEventListener.doEvict(Object object, EntityKey key, EntityPersister persister, SessionImplementor session)
           
 boolean DefaultDirtyCheckEventListener.onDirtyCheck(DirtyCheckEvent event)
          Handle the given dirty-check event.
 void DefaultDeleteEventListener.onDelete(DeleteEvent event)
          Handle the given delete event.
protected  void DefaultDeleteEventListener.deleteEntity(SessionImplementor session, Object entity, EntityEntry entityEntry, boolean isCascadeDeleteEnabled, EntityPersister persister)
           
protected  void DefaultDeleteEventListener.cascadeBeforeDelete(SessionImplementor session, EntityPersister persister, Object entity, EntityEntry entityEntry)
           
protected  void DefaultDeleteEventListener.cascadeAfterDelete(SessionImplementor session, EntityPersister persister, Object entity)
           
 boolean DefaultAutoFlushEventListener.onAutoFlush(AutoFlushEvent event)
          Handle the given auto-flush event.
 void AbstractVisitor.processEntityPropertyValues(Object[] values, Type[] types)
          Dispatch each property value to processValue().
protected  Serializable AbstractSaveEventListener.saveWithRequestedId(Object entity, Serializable requestedId, String entityName, Object anything, SessionImplementor source)
          Prepares the save call using the given requested id.
protected  Serializable AbstractSaveEventListener.saveWithGeneratedId(Object entity, String entityName, Object anything, SessionImplementor source)
          Prepares the save call using a newly generated id.
protected  Serializable AbstractSaveEventListener.performSave(Object entity, Serializable id, EntityPersister persister, boolean useIdentityColumn, Object anything, SessionImplementor source)
          Ppepares the save call by checking the session caches for a pre-existing entity and performing any lifecycle callbacks.
protected  Serializable AbstractSaveEventListener.performSaveOrReplicate(Object entity, Serializable id, EntityPersister persister, boolean useIdentityColumn, Object anything, SessionImplementor source)
          Performs all the actual work needed to save an entity (well to get the save moved to the execution queue).
protected  void AbstractSaveEventListener.cascadeBeforeSave(SessionImplementor source, EntityPersister persister, Object entity, Object anything)
          Handles the calls needed to perform pre-save cascades for the given entity.
protected  void AbstractSaveEventListener.cascadeAfterSave(SessionImplementor source, EntityPersister persister, Object entity, Object anything)
          Handles to calls needed to perform post-save cascades.
protected  EntityEntry AbstractReassociateEventListener.reassociate(AbstractEvent event, Object object, Serializable id, EntityPersister persister)
          Associates a given entity (either transient or associated with another session) to the given session.
protected  void AbstractLockUpgradeEventListener.upgradeLock(Object object, EntityEntry entry, LockMode requestedLockMode, SessionImplementor source)
          Performs a pessimistic lock upgrade on a given entity, if needed.
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(SessionImplementor 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.
 

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

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, SessionImplementor 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.
 

Uses of HibernateException in org.hibernate.hql.ast
 

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

Methods in org.hibernate.hql.ast that throw HibernateException
 int UpdateStatementExecutor.execute(QueryParameters parameters, SessionImplementor session)
          Execute the sql managed by this executor using the given parameters.
 List QueryTranslatorImpl.list(SessionImplementor session, QueryParameters queryParameters)
           
 Iterator QueryTranslatorImpl.iterate(QueryParameters queryParameters, SessionImplementor 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)
           
 

Uses of HibernateException in org.hibernate.hql.classic
 

Methods in org.hibernate.hql.classic that throw HibernateException
protected  int QueryTranslatorImpl.bindNamedParameters(PreparedStatement ps, Map namedParams, int start, SessionImplementor session)
           
 List QueryTranslatorImpl.list(SessionImplementor session, QueryParameters queryParameters)
           
 Iterator QueryTranslatorImpl.iterate(QueryParameters queryParameters, SessionImplementor session)
          Return the query results as an iterator
 int QueryTranslatorImpl.executeUpdate(QueryParameters queryParameters, SessionImplementor session)
           
protected  Object QueryTranslatorImpl.getResultColumnOrRow(Object[] row, ResultSet rs, SessionImplementor session)
           
 ScrollableResults QueryTranslatorImpl.scroll(QueryParameters queryParameters, SessionImplementor session)
           
 

Uses of HibernateException in org.hibernate.id
 

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

Methods in org.hibernate.id that throw HibernateException
 Serializable TableHiLoGenerator.generate(SessionImplementor session, Object obj)
           
 Serializable TableGenerator.generate(SessionImplementor session, Object object)
           
 String[] TableGenerator.sqlCreateStrings(Dialect dialect)
           
 Serializable SequenceHiLoGenerator.generate(SessionImplementor session, Object obj)
           
 Serializable SequenceGenerator.generate(SessionImplementor session, Object obj)
           
 String[] SequenceGenerator.sqlCreateStrings(Dialect dialect)
           
 String[] SequenceGenerator.sqlDropStrings(Dialect dialect)
           
 Serializable PostInsertIdentifierGenerator.getGenerated(SessionImplementor session, Object object, PostInsertIdentityPersister persister)
           
 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.
 String[] MultipleHiLoPerTableGenerator.sqlCreateStrings(Dialect dialect)
           
 String[] MultipleHiLoPerTableGenerator.sqlDropStrings(Dialect dialect)
           
 Serializable MultipleHiLoPerTableGenerator.generate(SessionImplementor session, Object obj)
           
 Serializable IncrementGenerator.generate(SessionImplementor session, Object object)
           
static Serializable IdentifierGeneratorFactory.getGeneratedIdentity(ResultSet rs, Type type)
          Get the generated identifier when using identity columns
 Serializable IdentifierGenerator.generate(SessionImplementor session, Object object)
          Generate a new identifier.
 Serializable GUIDGenerator.generate(SessionImplementor session, Object obj)
           
 Serializable ForeignGenerator.generate(SessionImplementor session, Object object)
           
 Serializable Assigned.generate(SessionImplementor session, Object obj)
           
 Serializable AbstractPostInsertGenerator.getGenerated(SessionImplementor session, Object object, PostInsertIdentityPersister persister)
           
 

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()
           
 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(Object object, LockMode lockMode)
           
 void SessionImpl.lock(String entityName, Object object, LockMode lockMode)
           
 void SessionImpl.persist(String entityName, Object object, Map copiedAlready)
           
 void SessionImpl.persist(String entityName, Object object)
           
 void SessionImpl.persist(Object object)
           
 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, boolean isCascadeDeleteEnabled)
          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.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)
 boolean SessionImpl.isDirty()
           
 void SessionImpl.flush()
           
 void SessionImpl.forceFlush(EntityEntry e)
           
 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)
           
 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.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()
           
 Session SessionFactoryImpl.openSession(Interceptor sessionLocalInterceptor)
           
 Session SessionFactoryImpl.openSession()
           
 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)
           
 boolean ScrollableResultsImpl.scroll(int i)
           
 boolean ScrollableResultsImpl.first()
           
 boolean ScrollableResultsImpl.last()
           
 boolean ScrollableResultsImpl.next()
           
 boolean ScrollableResultsImpl.previous()
           
 Object[] ScrollableResultsImpl.get()
           
 Object ScrollableResultsImpl.get(int col)
           
 BigDecimal ScrollableResultsImpl.getBigDecimal(int col)
           
 BigInteger ScrollableResultsImpl.getBigInteger(int col)
           
 byte[] ScrollableResultsImpl.getBinary(int col)
           
 String ScrollableResultsImpl.getText(int col)
           
 Blob ScrollableResultsImpl.getBlob(int col)
           
 Clob ScrollableResultsImpl.getClob(int col)
           
 Boolean ScrollableResultsImpl.getBoolean(int col)
           
 Byte ScrollableResultsImpl.getByte(int col)
           
 Character ScrollableResultsImpl.getCharacter(int col)
           
 Date ScrollableResultsImpl.getDate(int col)
           
 Calendar ScrollableResultsImpl.getCalendar(int col)
           
 Double ScrollableResultsImpl.getDouble(int col)
           
 Float ScrollableResultsImpl.getFloat(int col)
           
 Integer ScrollableResultsImpl.getInteger(int col)
           
 Long ScrollableResultsImpl.getLong(int col)
           
 Short ScrollableResultsImpl.getShort(int col)
           
 String ScrollableResultsImpl.getString(int col)
           
 void ScrollableResultsImpl.afterLast()
           
 void ScrollableResultsImpl.beforeFirst()
           
 void ScrollableResultsImpl.close()
           
 Locale ScrollableResultsImpl.getLocale(int col)
           
 TimeZone ScrollableResultsImpl.getTimeZone(int col)
           
 boolean ScrollableResultsImpl.isFirst()
           
 boolean ScrollableResultsImpl.isLast()
           
 int ScrollableResultsImpl.getRowNumber()
           
 boolean ScrollableResultsImpl.setRowNumber(int rowNumber)
           
 Iterator QueryImpl.iterate()
           
 ScrollableResults QueryImpl.scroll()
           
 ScrollableResults QueryImpl.scroll(ScrollMode scrollMode)
           
 List QueryImpl.list()
           
 int QueryImpl.executeUpdate()
           
 void FilterImpl.validate()
          Perform validation of the filter state.
 List CriteriaImpl.list()
           
 Criteria CriteriaImpl.createAlias(String associationPath, String alias)
           
 Object CriteriaImpl.uniqueResult()
           
 Criteria CriteriaImpl.createCriteria(String associationPath, String alias)
           
 Criteria CriteriaImpl.createCriteria(String associationPath)
           
 Criteria CriteriaImpl.Subcriteria.createAlias(String associationPath, String alias)
           
 Criteria CriteriaImpl.Subcriteria.createCriteria(String associationPath)
           
 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)
           
 Criteria CriteriaImpl.Subcriteria.createCriteria(String associationPath, String alias)
           
 Iterator CollectionFilterImpl.iterate()
           
 List CollectionFilterImpl.list()
           
 ScrollableResults CollectionFilterImpl.scroll()
           
protected  void AbstractQueryImpl.verifyParameters(boolean reserveFirstParameter)
           
 Query AbstractQueryImpl.setParameter(int position, Object val)
           
 Query AbstractQueryImpl.setParameter(String name, Object val)
           
 Type[] AbstractQueryImpl.getReturnTypes()
           
 String[] AbstractQueryImpl.getReturnAliases()
           
 Query AbstractQueryImpl.setParameterList(String name, Collection vals, Type type)
           
 Query AbstractQueryImpl.setParameterList(String name, Collection vals)
           
 String[] AbstractQueryImpl.getNamedParameters()
           
 Query AbstractQueryImpl.setProperties(Object bean)
           
 Query AbstractQueryImpl.setParameterList(String name, Object[] vals, Type type)
           
 Query AbstractQueryImpl.setParameterList(String name, Object[] vals)
           
 Object AbstractQueryImpl.uniqueResult()
           
 int AbstractQueryImpl.executeUpdate()
           
 

Constructors in org.hibernate.impl that throw HibernateException
SessionFactoryImpl(Configuration cfg, Mapping mapping, Settings settings, SessionEventListenerConfig listeners)
           
IteratorImpl(ResultSet rs, PreparedStatement ps, SessionImplementor 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
 

Methods in org.hibernate.jdbc that throw HibernateException
 void NonBatchingBatcher.addToBatch(int expectedRowCount)
           
protected  void NonBatchingBatcher.doExecuteBatch(PreparedStatement ps)
           
 Connection JDBCContext.connection()
           
 Transaction JDBCContext.beginTransaction()
           
 Connection ConnectionManager.getConnection()
          Retreives the connection currently managed by this ConnectionManager.
 void BatchingBatcher.addToBatch(int expectedRowCount)
           
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.
 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(int expectedRowCount)
          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
 CallableStatement AbstractBatcher.prepareCallableStatement(String sql)
           
 PreparedStatement AbstractBatcher.prepareStatement(String sql)
           
 PreparedStatement AbstractBatcher.prepareStatement(String sql, boolean getGeneratedKeys)
           
 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()
           
 

Uses of HibernateException in org.hibernate.jmx
 

Methods in org.hibernate.jmx that throw HibernateException
 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)
           
 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
 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)
           
protected  Object Loader.getResultColumnOrRow(Object[] row, ResultSet rs, SessionImplementor session)
          Get the actual object that is returned in the user-visible result list.
protected  int Loader.bindPositionalParameters(PreparedStatement st, QueryParameters queryParameters, int start, SessionImplementor session)
          Bind positional parameter values to the PreparedStatement (these are parameters specified by a JDBC-style ?).
protected  PreparedStatement Loader.prepareQueryStatement(QueryParameters queryParameters, boolean scroll, SessionImplementor session)
          Obtain a PreparedStatement with all parameters pre-bound.
protected  ResultSet Loader.getResultSet(PreparedStatement st, RowSelection selection, SessionImplementor session)
           
protected  ResultSet Loader.getResultSet(PreparedStatement st, 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  int Loader.bindNamedParameters(PreparedStatement st, Map namedParams, int start, SessionImplementor session)
          Bind named parameters to the PreparedStatement.
protected  List Loader.loadEntity(SessionImplementor session, Object id, Type identifierType, Object optionalObject, String optionalEntityName, Serializable optionalIdentifier, 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  ScrollableResults Loader.scroll(QueryParameters queryParameters, Type[] returnTypes, Class holderClass, SessionImplementor session)
          Return the query results, as an instance of ScrollableResults
 

Uses of HibernateException in org.hibernate.loader.collection
 

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

Uses of HibernateException in org.hibernate.loader.criteria
 

Methods in org.hibernate.loader.criteria that throw HibernateException
 String[] CriteriaQueryTranslator.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.
 ScrollableResults CriteriaLoader.scroll(SessionImplementor session, ScrollMode scrollMode)
           
 List CriteriaLoader.list(SessionImplementor session)
           
protected  Object CriteriaLoader.getResultColumnOrRow(Object[] row, ResultSet rs, SessionImplementor session)
           
 

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

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, ResultSet rs, SessionImplementor session)
           
protected  int CustomLoader.bindNamedParameters(PreparedStatement ps, Map namedParams, int start, SessionImplementor session)
           
 

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

Uses of HibernateException in org.hibernate.loader.entity
 

Methods in org.hibernate.loader.entity that throw HibernateException
 Object UniqueEntityLoader.load(Serializable id, Object optionalObject, SessionImplementor session)
          Load an entity instance.
 Object EntityLoader.load(Serializable id, Object optionalObject, SessionImplementor session)
           
 Object EntityLoader.loadByUniqueKey(SessionImplementor session, Object key)
           
protected  Object EntityLoader.getResultColumnOrRow(Object[] row, ResultSet rs, SessionImplementor session)
           
 Object BatchingEntityLoader.load(Serializable id, Object optionalObject, SessionImplementor session)
           
 

Uses of HibernateException in org.hibernate.loader.hql
 

Methods in org.hibernate.loader.hql that throw HibernateException
protected  int QueryLoader.bindNamedParameters(PreparedStatement ps, Map namedParams, int start, SessionImplementor session)
           
protected  Object QueryLoader.getResultColumnOrRow(Object[] row, ResultSet rs, SessionImplementor session)
           
 List QueryLoader.list(SessionImplementor session, QueryParameters queryParameters)
          Delegats
 Iterator QueryLoader.iterate(QueryParameters queryParameters, SessionImplementor session)
          Return the query results as an iterator
 ScrollableResults QueryLoader.scroll(QueryParameters queryParameters, SessionImplementor session)
           
 

Uses of HibernateException in org.hibernate.mapping
 

Methods in org.hibernate.mapping that throw HibernateException
 Iterator Table.sqlAlterStrings(Dialect dialect, Mapping p, TableMetadata tableInfo, String defaultCatalog, String defaultSchema)
           
 String Table.sqlCreateString(Dialect dialect, Mapping p, String defaultCatalog, String defaultSchema)
           
 String RelationalModel.sqlCreateString(Dialect dialect, Mapping p, String defaultCatalog, String defaultSchema)
           
 String Index.sqlCreateString(Dialect dialect, Mapping mapping, String defaultCatalog, String defaultSchema)
           
 String 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, 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
protected  int BasicCollectionPersister.doUpdateRows(Serializable id, PersistentCollection collection, SessionImplementor session)
           
 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)
           
 

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 NamedQueryLoader.load(Serializable id, Object optionalObject, SessionImplementor session)
           
 Object[] Loadable.hydrate(ResultSet rs, Serializable id, Object object, Loadable rootLoadable, SessionImplementor session, String[][] suffixedPropertyColumns, boolean allProperties)
          Retrieve property values from one row of a result set
 int[] EntityPersister.findDirty(Object[] x, Object[] y, Object owner, SessionImplementor session)
          Compare two snapshots of the state of an instance to determine if the persistent state was modified
 int[] EntityPersister.findModified(Object[] old, Object[] current, Object object, SessionImplementor session)
          Compare the state of an instance to the current database state
 IdentifierGenerator EntityPersister.getIdentifierGenerator()
          Return the IdentifierGenerator for the class
 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.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, 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
 Object BasicEntityPersister.initializeLazyProperty(String fieldName, Object entity, SessionImplementor session)
           
 Object[] BasicEntityPersister.getDatabaseSnapshot(Serializable id, SessionImplementor session)
           
 void BasicEntityPersister.lock(Serializable id, Object version, Object object, LockMode lockMode, SessionImplementor session)
          Do a version check
 Object BasicEntityPersister.getCurrentVersion(Serializable id, SessionImplementor session)
          Retrieve the version number
 Object BasicEntityPersister.loadByUniqueKey(String propertyName, Object uniqueKey, SessionImplementor session)
           
protected  boolean BasicEntityPersister.check(int rows, Serializable id, int tableNumber)
           
protected  int BasicEntityPersister.dehydrate(Serializable id, Object[] fields, boolean[] includeProperty, boolean[][] includeColumns, int j, PreparedStatement st, SessionImplementor session)
           
protected  int BasicEntityPersister.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[] BasicEntityPersister.hydrate(ResultSet rs, Serializable id, Object object, Loadable rootLoadable, SessionImplementor session, String[][] suffixedPropertyColumns, boolean allProperties)
          Unmarshall the fields of a persistent instance from a result set, without resolving associations or collections.
protected  Serializable BasicEntityPersister.insert(Object[] fields, boolean[] notNull, String sql, Object object, SessionImplementor session)
          Perform an SQL INSERT, and then retrieve a generated identifier
protected  void BasicEntityPersister.insert(Serializable id, Object[] fields, boolean[] notNull, int j, String sql, Object object, SessionImplementor session)
          Perform an SQL INSERT
protected  void BasicEntityPersister.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 BasicEntityPersister.update(Serializable id, Object[] fields, Object[] oldFields, Object rowId, boolean[] includeProperty, int j, Object oldVersion, Object object, String sql, SessionImplementor session)
           
protected  void BasicEntityPersister.delete(Serializable id, Object version, int j, Object object, String sql, SessionImplementor session)
          Perform an SQL DELETE
 void BasicEntityPersister.update(Serializable id, Object[] fields, int[] dirtyFields, boolean hasDirtyCollection, Object[] oldFields, Object oldVersion, Object object, Object rowId, SessionImplementor session)
          Update an object
 Serializable BasicEntityPersister.insert(Object[] fields, Object object, SessionImplementor session)
           
 void BasicEntityPersister.insert(Serializable id, Object[] fields, Object object, SessionImplementor session)
           
 void BasicEntityPersister.delete(Serializable id, Object version, Object object, SessionImplementor session)
          Delete an object
 Object BasicEntityPersister.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[] BasicEntityPersister.findDirty(Object[] currentState, Object[] previousState, Object entity, SessionImplementor session)
          Locate the property-indices of all properties considered to be dirty.
 int[] BasicEntityPersister.findModified(Object[] old, Object[] current, Object entity, SessionImplementor session)
          Locate the property-indices of all properties considered to be dirty.
 Boolean BasicEntityPersister.isTransient(Object entity, SessionImplementor session)
           
 IdentifierGenerator BasicEntityPersister.getIdentifierGenerator()
           
 Object BasicEntityPersister.createProxy(Serializable id, SessionImplementor session)
           
 void BasicEntityPersister.setPropertyValues(Object object, Object[] values, EntityMode entityMode)
           
 void BasicEntityPersister.setPropertyValue(Object object, int i, Object value, EntityMode entityMode)
           
 Object[] BasicEntityPersister.getPropertyValues(Object object, EntityMode entityMode)
           
 Object BasicEntityPersister.getPropertyValue(Object object, int i, EntityMode entityMode)
           
 Object BasicEntityPersister.getPropertyValue(Object object, String propertyName, EntityMode entityMode)
           
 Serializable BasicEntityPersister.getIdentifier(Object object, EntityMode entityMode)
           
 void BasicEntityPersister.setIdentifier(Object object, Serializable id, EntityMode entityMode)
           
 Object BasicEntityPersister.getVersion(Object object, EntityMode entityMode)
           
 Object BasicEntityPersister.instantiate(Serializable id, EntityMode entityMode)
           
 Object[] BasicEntityPersister.getPropertyValuesToInsert(Object object, SessionImplementor session)
           
 void BasicEntityPersister.setPropertyValue(Object object, String propertyName, Object value, EntityMode entityMode)
           
 

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

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 Setter.set(Object target, Object value, SessionFactoryImplementor factory)
          Set the property value from the given instance
 void MapAccessor.MapSetter.set(Object target, Object value, SessionFactoryImplementor factory)
           
 Object MapAccessor.MapGetter.get(Object target)
           
 void IndexPropertyAccessor.IndexSetter.set(Object target, Object value, SessionFactoryImplementor factory)
           
 Object IndexPropertyAccessor.IndexGetter.getForInsert(Object target, SessionImplementor session)
           
 Object Getter.get(Object owner)
          Get the property value from the given instance .
 Object Getter.getForInsert(Object owner, SessionImplementor session)
          Get the property value from the given owner instance.
 Object EmbeddedPropertyAccessor.EmbeddedGetter.get(Object target)
           
 void EmbeddedPropertyAccessor.EmbeddedSetter.set(Object target, Object value, SessionFactoryImplementor factory)
           
 Object Dom4jAccessor.Dom4jGetter.getForInsert(Object owner, 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)
           
 void BasicPropertyAccessor.BasicSetter.set(Object target, Object value, SessionFactoryImplementor factory)
           
 Object BasicPropertyAccessor.BasicGetter.get(Object target)
           
 Object BackrefPropertyAccessor.BackrefGetter.getForInsert(Object target, SessionImplementor session)
           
 

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
 HibernateProxy ProxyFactory.getProxy(Serializable id, SessionImplementor session)
          Create a new proxy
 void MapProxyFactory.postInstantiate(String entityName, Class persistentClass, Set interfaces, Method getIdentifierMethod, Method setIdentifierMethod, AbstractComponentType componentIdType)
           
 HibernateProxy MapProxyFactory.getProxy(Serializable id, SessionImplementor session)
           
 void LazyInitializer.initialize()
          Initialize the proxy, fetching the target entity if necessary
 void LazyInitializer.setSession(SessionImplementor s)
          Attach the proxy to a session
 Object LazyInitializer.getImplementation(SessionImplementor s)
          Return the underlying persistent object in the given Session, or null
 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
 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(net.sf.cglib.proxy.Factory factory, String entityName, Class persistentClass, Class[] interfaces, Method getIdentifierMethod, Method setIdentifierMethod, AbstractComponentType componentIdType, Serializable id, SessionImplementor session)
           
static net.sf.cglib.proxy.Factory CGLIBLazyInitializer.getProxyFactory(Class persistentClass, Class[] interfaces)
           
 void AbstractLazyInitializer.initialize()
           
 void AbstractLazyInitializer.setSession(SessionImplementor s)
           
 Object AbstractLazyInitializer.getImplementation(SessionImplementor s)
          Return the underlying persistent object in the given Session, or null, do not initialize the proxy
 

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 DatabaseMetadata.isTable(Object key)
           
 

Constructors in org.hibernate.tool.hbm2ddl that throw HibernateException
SchemaUpdate(Configuration cfg)
           
SchemaUpdate(Configuration cfg, Properties connectionProperties)
           
SchemaExport(Configuration cfg)
          Create a schema exporter for the given Configuration
SchemaExport(Configuration cfg, Properties connectionProperties)
          Create a schema exporter for the given Configuration, with the given database connection properties.
 

Uses of HibernateException in org.hibernate.transaction
 

Methods in org.hibernate.transaction that throw HibernateException
 TransactionManager WebSphereTransactionManagerLookup.getTransactionManager(Properties props)
           
 TransactionManager WebSphereExtendedJTATransactionLookup.getTransactionManager(Properties props)
           
static TransactionManager TransactionManagerLookupFactory.getTransactionManager(Properties props)
           
static TransactionManagerLookup TransactionManagerLookupFactory.getTransactionManagerLookup(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.
 Transaction TransactionFactory.beginTransaction(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 JTATransactionFactory.configure(Properties props)
           
 Transaction JTATransactionFactory.beginTransaction(JDBCContext jdbcContext, TransactionFactory.Context transactionContext)
           
 void JTATransaction.begin(InitialContext context, String utName)
           
 void JTATransaction.commit()
           
 void JTATransaction.rollback()
           
 void JTATransaction.registerSynchronization(Synchronization sync)
           
 TransactionManager JOTMTransactionManagerLookup.getTransactionManager(Properties props)
           
 TransactionManager JOnASTransactionManagerLookup.getTransactionManager(Properties props)
           
 TransactionManager JNDITransactionManagerLookup.getTransactionManager(Properties props)
           
 Transaction JDBCTransactionFactory.beginTransaction(JDBCContext jdbcContext, TransactionFactory.Context transactionContext)
           
 void JDBCTransactionFactory.configure(Properties props)
           
 void JDBCTransaction.begin()
           
 void JDBCTransaction.commit()
           
 void JDBCTransaction.rollback()
           
 void JDBCTransaction.registerSynchronization(Synchronization sync)
           
 void CMTTransactionFactory.configure(Properties props)
           
 Transaction CMTTransactionFactory.beginTransaction(JDBCContext jdbcContext, TransactionFactory.Context transactionContext)
           
 void CMTTransaction.begin()
           
 void CMTTransaction.commit()
           
 void CMTTransaction.rollback()
           
 void CMTTransaction.registerSynchronization(Synchronization sync)
           
 

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()
           
 void PojoTuplizer.setPropertyValues(Object entity, Object[] values)
           
 Object[] PojoTuplizer.getPropertyValues(Object entity)
           
 Object[] PojoTuplizer.getPropertyValuesToInsert(Object entity, SessionImplementor session)
           
 Object[] PojoComponentTuplizer.getPropertyValues(Object component)
           
 void PojoComponentTuplizer.setPropertyValues(Object component, Object[] values)
           
 Object EntityTuplizer.instantiate(Serializable id)
          Create an entity instance initialized with the given identifier.
 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, 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.
 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.
 Object EntityTuplizer.createProxy(Serializable id, SessionImplementor session)
          Generates an appropriate proxy representation of this entity for this entity-mode.
 Serializable Dom4jTuplizer.getIdentifier(Object entityOrId)
           
 Serializable AbstractTuplizer.getIdentifier(Object entity)
           
 void AbstractTuplizer.setIdentifier(Object entity, Serializable id)
           
 Object AbstractTuplizer.getVersion(Object entity)
           
 Object[] AbstractTuplizer.getPropertyValues(Object entity)
           
 Object[] AbstractTuplizer.getPropertyValuesToInsert(Object entity, SessionImplementor session)
           
 Object AbstractTuplizer.getPropertyValue(Object entity, int i)
           
 Object AbstractTuplizer.getPropertyValue(Object entity, String propertyName)
           
 void AbstractTuplizer.setPropertyValues(Object entity, Object[] values)
           
 void AbstractTuplizer.setPropertyValue(Object entity, int i, Object value)
           
 void AbstractTuplizer.setPropertyValue(Object entity, String propertyName, Object value)
           
 Object AbstractTuplizer.instantiate(Serializable id)
           
 Object AbstractTuplizer.instantiate()
           
 Object AbstractTuplizer.createProxy(Serializable id, SessionImplementor session)
           
 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.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
static void TypeFactory.deepCopy(Object[] values, Type[] types, boolean[] copy, Object[] target, SessionImplementor session)
          Deep copy values in the first array into the second
static Object[] TypeFactory.assemble(Serializable[] row, Type[] types, SessionImplementor session, Object owner)
          Determine if any of the given field values are modified, returning an array containing indexes of the dirty fields or null if no fields are dirty.
static Serializable[] TypeFactory.disassemble(Object[] row, Type[] types, SessionImplementor session, Object owner)
           
static Object[] TypeFactory.replace(Object[] original, Object[] target, Type[] types, SessionImplementor session, Object owner, Map copyCache)
           
static int[] TypeFactory.findDirty(StandardProperty[] properties, Object[] x, Object[] y, boolean anyUninitializedProperties, SessionImplementor session)
          Determine if any of the given field values are dirty, returning an array containing indexes of the dirty fields or null if no fields are dirty.
static int[] TypeFactory.findModified(StandardProperty[] properties, Object[] x, Object[] y, boolean anyUninitializedProperties, SessionImplementor session)
          Determine if any of the given field values are modified, returning an array containing indexes of the dirty fields or null if no fields are dirty.
 boolean Type.isSame(Object x, Object y, EntityMode entityMode)
          Compare two instances of the class mapped by this type for persistence "equality" - equality of persistent state - taking a shortcut for entity references.
 boolean Type.isEqual(Object x, Object y, EntityMode entityMode)
          Compare two instances of the class mapped by this type for persistence "equality" - equality of persistent state.
 boolean Type.isEqual(Object x, Object y, EntityMode entityMode, SessionFactoryImplementor factory)
          Compare two instances of the class mapped by this type for persistence "equality" - equality of persistent state.
 int Type.getHashCode(Object x, EntityMode entityMode)
          Get a hashcode, consistent with persistence "equality"
 int Type.getHashCode(Object x, EntityMode entityMode, SessionFactoryImplementor factory)
          Get a hashcode, consistent with persistence "equality"
 boolean Type.isDirty(Object old, Object current, SessionImplementor session)
          Should the parent be considered dirty, given both the old and current field or element value?
 boolean Type.isModified(Object oldHydratedState, Object currentState, SessionImplementor session)
          Has the parent object been modified, compared to the current database state?
 Object Type.nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)
          Retrieve an instance of the mapped class from a JDBC resultset.
 Object Type.nullSafeGet(ResultSet rs, String name, SessionImplementor session, Object owner)
          Retrieve an instance of the mapped class from a JDBC resultset.
 void Type.nullSafeSet(PreparedStatement st, Object value, int index, boolean[] settable, SessionImplementor session)
          Write an instance of the mapped class to a prepared statement, ignoring some columns.
 void Type.nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)
          Write an instance of the mapped class to a prepared statement.
 void Type.setToXMLNode(org.dom4j.Node node, Object value, SessionFactoryImplementor factory)
          A representation of the value to be embedded in an XML element.
 String Type.toLoggableString(Object value, SessionFactoryImplementor factory)
          A representation of the value to be embedded in a log file.
 Object Type.fromXMLNode(org.dom4j.Node xml, Mapping factory)
          Parse the XML representation of an instance.
 Object Type.deepCopy(Object value, EntityMode entityMode, SessionFactoryImplementor factory)
          Return a deep copy of the persistent state, stopping at entities and at collections.
 Serializable Type.disassemble(Object value, SessionImplementor session, Object owner)
          Return a cacheable "disassembled" representation of the object.
 Object Type.assemble(Serializable cached, SessionImplementor session, Object owner)
          Reconstruct the object from its cached "disassembled" state.
 Object Type.hydrate(ResultSet rs, String[] names, SessionImplementor session, Object owner)
          Retrieve an instance of the mapped class, or the identifier of an entity or collection, from a JDBC resultset.
 Object Type.resolve(Object value, SessionImplementor session, Object owner)
          Map identifiers to entities or collections.
 Object Type.semiResolve(Object value, SessionImplementor session, Object owner)
          Given a hydrated, but unresolved value, return a value that may be used to reconstruct property-ref associations.
 Object Type.replace(Object original, Object target, SessionImplementor session, Object owner, Map copyCache)
          During merge, replace the existing (target) value in the entity we are merging to with a new (original) value from the detached entity we are merging.
 Object TimeZoneType.get(ResultSet rs, String name)
           
 void TimeZoneType.set(PreparedStatement st, Object value, int index)
           
 String TimeZoneType.toString(Object value)
           
 Object TimeZoneType.fromStringValue(String xml)
           
 Object TimeType.fromStringValue(String xml)
           
 Object TimestampType.fromStringValue(String xml)
           
 void TextType.set(PreparedStatement st, Object value, int index)
           
 Object TextType.get(ResultSet rs, String name)
           
 Object SpecialOneToOneType.hydrate(ResultSet rs, String[] names, SessionImplementor session, Object owner)
           
 Serializable SpecialOneToOneType.disassemble(Object value, SessionImplementor session, Object owner)
           
 Object SpecialOneToOneType.assemble(Serializable oid, SessionImplementor session, Object owner)
           
 void SerializableType.set(PreparedStatement st, Object value, int index)
           
 Object SerializableType.get(ResultSet rs, String name)
           
 boolean SerializableType.isEqual(Object x, Object y)
           
 String SerializableType.toString(Object value)
           
 Object SerializableType.fromStringValue(String xml)
           
 Object SerializableType.deepCopyNotNull(Object value)
           
 Object SerializableType.assemble(Serializable cached, SessionImplementor session, Object owner)
           
 Serializable SerializableType.disassemble(Object value, SessionImplementor session, Object owner)
           
 boolean QueryType.isDirty(Object old, Object current, SessionImplementor session)
           
 Object QueryType.nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)
           
 Object QueryType.nullSafeGet(ResultSet rs, String name, SessionImplementor session, Object owner)
           
 void QueryType.nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)
           
 void QueryType.nullSafeSet(PreparedStatement st, Object value, int index, boolean[] settable, SessionImplementor session)
           
 Object QueryType.fromXMLNode(org.dom4j.Node xml, Mapping factory)
           
 void QueryType.setToXMLNode(org.dom4j.Node node, Object value, SessionFactoryImplementor factory)
           
 String QueryType.toLoggableString(Object value, SessionFactoryImplementor factory)
           
 Object QueryType.deepCopy(Object value, EntityMode entityMode, SessionFactoryImplementor factory)
           
 Object QueryType.assemble(Serializable cached, SessionImplementor session, Object owner)
           
 Serializable QueryType.disassemble(Object value, SessionImplementor session, Object owner)
           
 Object QueryType.replace(Object original, Object target, SessionImplementor session, Object owner, Map copyCache)
           
 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)
           
abstract  Object NullableType.get(ResultSet rs, String name)
           
abstract  void NullableType.set(PreparedStatement st, Object value, int index)
           
abstract  String NullableType.toString(Object value)
           
abstract  Object NullableType.fromStringValue(String xml)
           
 void NullableType.nullSafeSet(PreparedStatement st, Object value, int index, boolean[] settable, SessionImplementor session)
           
 void NullableType.nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)
           
 void NullableType.nullSafeSet(PreparedStatement st, Object value, int index)
           
 Object NullableType.nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)
           
 Object NullableType.nullSafeGet(ResultSet rs, String[] names)
           
 Object NullableType.nullSafeGet(ResultSet rs, String name)
           
 Object NullableType.nullSafeGet(ResultSet rs, String name, SessionImplementor session, Object owner)
           
 String NullableType.toXMLString(Object value, SessionFactoryImplementor pc)
           
 Object NullableType.fromXMLString(String xml, Mapping factory)
           
 Object NullableType.fromXMLNode(org.dom4j.Node xml, Mapping factory)
           
 void NullableType.setToXMLNode(org.dom4j.Node xml, Object value, SessionFactoryImplementor factory)
           
protected abstract  Object MutableType.deepCopyNotNull(Object value)
           
 Object MutableType.deepCopy(Object value, EntityMode entityMode, SessionFactoryImplementor factory)
           
 Object MutableType.replace(Object original, Object target, SessionImplementor session, Object owner, Map copyCache)
           
 Object MetaType.nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)
           
 Object MetaType.nullSafeGet(ResultSet rs, String name, SessionImplementor session, Object owner)
           
 void MetaType.nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)
           
 void MetaType.nullSafeSet(PreparedStatement st, Object value, int index, boolean[] settable, SessionImplementor session)
           
 String MetaType.toLoggableString(Object value, SessionFactoryImplementor factory)
           
 String MetaType.toXMLString(Object value, SessionFactoryImplementor factory)
           
 Object MetaType.fromXMLString(String xml, Mapping factory)
           
 Object MetaType.deepCopy(Object value, EntityMode entityMode, SessionFactoryImplementor factory)
           
 Object MetaType.fromXMLNode(org.dom4j.Node xml, Mapping factory)
           
 void MetaType.setToXMLNode(org.dom4j.Node node, Object value, SessionFactoryImplementor factory)
           
 void MapType.replaceElements(Object original, Object target, Object owner, Map copyCache, SessionImplementor session)
           
 void ManyToOneType.nullSafeSet(PreparedStatement st, Object value, int index, boolean[] settable, SessionImplementor session)
           
 void ManyToOneType.nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)
           
 Object ManyToOneType.hydrate(ResultSet rs, String[] names, SessionImplementor session, Object owner)
           
 boolean ManyToOneType.isModified(Object old, Object current, SessionImplementor session)
           
 Serializable ManyToOneType.disassemble(Object value, SessionImplementor session, Object owner)
           
 Object ManyToOneType.assemble(Serializable oid, SessionImplementor session, Object owner)
           
 Object LocaleType.get(ResultSet rs, String name)
           
 void LocaleType.set(PreparedStatement st, Object value, int index)
           
 String LocaleType.toString(Object value)
           
 Object ImmutableType.replace(Object original, Object target, SessionImplementor session, Object owner, Map copyCache)
           
 PersistentCollection IdentifierBagType.instantiate(SessionImplementor session, CollectionPersister persister, Serializable key)
           
 Object EntityType.nullSafeGet(ResultSet rs, String name, SessionImplementor session, Object owner)
           
protected  Object EntityType.getIdentifier(Object value, SessionImplementor session)
           
 String EntityType.toLoggableString(Object value, SessionFactoryImplementor factory)
           
 Object EntityType.replace(Object original, Object target, SessionImplementor session, Object owner, Map copyCache)
           
 Object EntityType.nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)
           
 boolean EntityType.isDirty(Object old, Object current, SessionImplementor session)
           
protected  Object EntityType.resolveIdentifier(Serializable id, SessionImplementor session)
          Resolve an identifier
 Object EntityType.resolve(Object value, SessionImplementor session, Object owner)
          Resolve an identifier or unique key value
 Object EntityType.loadByUniqueKey(String entityName, String uniqueKeyPropertyName, Object key, SessionImplementor session)
          Load an instance by a unique key that is not the primary key.
 Object EntityType.fromXMLNode(org.dom4j.Node xml, Mapping factory)
           
 void EntityType.setToXMLNode(org.dom4j.Node node, Object value, SessionFactoryImplementor factory)
           
 Object EmbeddedComponentType.instantiate(Object parent, SessionImplementor session)
           
 Object DateType.fromStringValue(String xml)
           
 boolean CustomType.isEqual(Object x, Object y)
           
 boolean CustomType.isEqual(Object x, Object y, EntityMode entityMode)
           
 Object CustomType.nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)
           
 Object CustomType.nullSafeGet(ResultSet rs, String columnName, SessionImplementor session, Object owner)
           
 Object CustomType.assemble(Serializable cached, SessionImplementor session, Object owner)
           
 Serializable CustomType.disassemble(Object value, SessionImplementor session, Object owner)
           
 Object CustomType.replace(Object original, Object target, SessionImplementor session, Object owner, Map copyCache)
           
 void CustomType.nullSafeSet(PreparedStatement st, Object value, int index, boolean[] settable, SessionImplementor session)
           
 void CustomType.nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)
           
 Object CustomType.deepCopy(Object value, EntityMode entityMode, SessionFactoryImplementor factory)
           
 Object CustomType.fromXMLNode(org.dom4j.Node xml, Mapping factory)
           
 void CustomType.setToXMLNode(org.dom4j.Node node, Object value, SessionFactoryImplementor factory)
           
 String CustomType.toLoggableString(Object value, SessionFactoryImplementor factory)
           
 PersistentCollection CustomCollectionType.instantiate(SessionImplementor session, CollectionPersister persister, Serializable key)
           
 void CustomCollectionType.replaceElements(Object original, Object target, Object owner, Map copyCache, 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[] CompositeCustomType.getPropertyValues(Object component, SessionImplementor session)
           
 Object[] CompositeCustomType.getPropertyValues(Object component, EntityMode entityMode)
           
 void CompositeCustomType.setPropertyValues(Object component, Object[] values, EntityMode entityMode)
           
 Object CompositeCustomType.getPropertyValue(Object component, int i, SessionImplementor session)
           
 Object CompositeCustomType.getPropertyValue(Object component, int i)
           
 Object CompositeCustomType.deepCopy(Object value, EntityMode entityMode, SessionFactoryImplementor factory)
           
 Object CompositeCustomType.assemble(Serializable cached, SessionImplementor session, Object owner)
           
 Serializable CompositeCustomType.disassemble(Object value, SessionImplementor session, Object owner)
           
 Object CompositeCustomType.replace(Object original, Object target, SessionImplementor session, Object owner, Map copyCache)
           
 boolean CompositeCustomType.isEqual(Object x, Object y, EntityMode entityMode)
           
 Object CompositeCustomType.nullSafeGet(ResultSet rs, String columnName, SessionImplementor session, Object owner)
           
 Object CompositeCustomType.nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)
           
 void CompositeCustomType.nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)
           
 void CompositeCustomType.nullSafeSet(PreparedStatement st, Object value, int index, boolean[] settable, SessionImplementor session)
           
 String CompositeCustomType.toLoggableString(Object value, SessionFactoryImplementor factory)
           
 Object CompositeCustomType.fromXMLNode(org.dom4j.Node xml, Mapping factory)
           
 void CompositeCustomType.setToXMLNode(org.dom4j.Node node, Object value, SessionFactoryImplementor factory)
           
 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)
           
 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)
           
 Object[] ComponentType.getPropertyValues(Object component, SessionImplementor session)
           
 Object[] ComponentType.getPropertyValues(Object component, EntityMode entityMode)
           
 void ComponentType.setPropertyValues(Object component, Object[] values, EntityMode entityMode)
           
 String ComponentType.toLoggableString(Object value, SessionFactoryImplementor factory)
           
 Object ComponentType.deepCopy(Object component, EntityMode entityMode, SessionFactoryImplementor factory)
           
 Object ComponentType.replace(Object original, Object target, SessionImplementor session, Object owner, Map copyCache)
           
 Object ComponentType.instantiate(Object parent, SessionImplementor session)
           
 Serializable ComponentType.disassemble(Object value, SessionImplementor session, Object owner)
           
 Object ComponentType.assemble(Serializable object, SessionImplementor session, Object owner)
           
 Object ComponentType.hydrate(ResultSet rs, String[] names, SessionImplementor session, Object owner)
           
 Object ComponentType.resolve(Object value, SessionImplementor session, Object owner)
           
 Object ComponentType.semiResolve(Object value, SessionImplementor session, Object owner)
           
 boolean ComponentType.isModified(Object old, Object current, SessionImplementor session)
           
 Object ComponentType.fromXMLNode(org.dom4j.Node xml, Mapping factory)
           
 void ComponentType.setToXMLNode(org.dom4j.Node node, Object value, SessionFactoryImplementor factory)
           
abstract  PersistentCollection CollectionType.instantiate(SessionImplementor session, CollectionPersister persister, Serializable key)
          Instantiate an uninitialized collection wrapper or holder.
 Object CollectionType.nullSafeGet(ResultSet rs, String name, SessionImplementor session, Object owner)
           
 Object CollectionType.nullSafeGet(ResultSet rs, String[] name, SessionImplementor session, Object owner)
           
 void CollectionType.nullSafeSet(PreparedStatement st, Object value, int index, boolean[] settable, SessionImplementor session)
           
 void CollectionType.nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)
           
 String CollectionType.toLoggableString(Object value, SessionFactoryImplementor factory)
           
 Object CollectionType.deepCopy(Object value, EntityMode entityMode, SessionFactoryImplementor factory)
           
 Serializable CollectionType.disassemble(Object value, SessionImplementor session, Object owner)
           
 Object CollectionType.assemble(Serializable cached, SessionImplementor session, Object owner)
           
 boolean CollectionType.isDirty(Object old, Object current, SessionImplementor session)
           
 Object CollectionType.resolve(Object value, SessionImplementor session, Object owner)
           
 Object CollectionType.semiResolve(Object value, SessionImplementor session, Object owner)
           
 boolean CollectionType.isModified(Object old, Object current, SessionImplementor session)
           
 void CollectionType.replaceElements(Object original, Object target, Object owner, Map copyCache, SessionImplementor session)
          Replace the elements of a collection with the elements of another collection
 Object CollectionType.replace(Object original, Object target, SessionImplementor session, Object owner, Map copyCache)
           
 Object CollectionType.getCollection(Serializable key, SessionImplementor session, Object owner)
          instantiate a collection wrapper (called when loading an object)
 Object CollectionType.fromXMLNode(org.dom4j.Node xml, Mapping factory)
           
 void CollectionType.setToXMLNode(org.dom4j.Node node, Object value, SessionFactoryImplementor factory)
           
 void ClobType.set(PreparedStatement st, Object value, int index, SessionImplementor session)
           
 Object ClobType.get(ResultSet rs, String name)
           
 Serializable ClobType.disassemble(Object value, SessionImplementor session, Object owner)
           
 Object ClobType.nullSafeGet(ResultSet rs, String name, SessionImplementor session, Object owner)
           
 Object ClobType.nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)
           
 void ClobType.nullSafeSet(PreparedStatement st, Object value, int index, boolean[] settable, SessionImplementor session)
           
 void ClobType.nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)
           
 Object ClobType.replace(Object original, Object target, SessionImplementor session, Object owner, Map copyCache)
           
 String ClobType.toLoggableString(Object value, SessionFactoryImplementor factory)
           
 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 CalendarType.get(ResultSet rs, String name)
           
 void CalendarType.set(PreparedStatement st, Object value, int index)
           
 String CalendarType.toString(Object value)
           
 Object CalendarType.fromStringValue(String xml)
           
 Object CalendarType.deepCopyNotNull(Object value)
           
 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)
           
 void BlobType.set(PreparedStatement st, Object value, int index, SessionImplementor session)
           
 Object BlobType.get(ResultSet rs, String name)
           
 Serializable BlobType.disassemble(Object value, SessionImplementor session, Object owner)
           
 Object BlobType.nullSafeGet(ResultSet rs, String name, SessionImplementor session, Object owner)
           
 Object BlobType.nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)
           
 void BlobType.nullSafeSet(PreparedStatement st, Object value, int index, boolean[] settable, SessionImplementor session)
           
 void BlobType.nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)
           
 Object BlobType.replace(Object original, Object target, SessionImplementor session, Object owner, Map copyCache)
           
 String BlobType.toLoggableString(Object value, SessionFactoryImplementor factory)
           
 void BinaryType.set(PreparedStatement st, Object value, int index)
           
 Object BinaryType.get(ResultSet rs, String name)
           
 Object BinaryType.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 BigDecimalType.get(ResultSet rs, String name)
           
 void BigDecimalType.set(PreparedStatement st, Object value, int index)
           
 String BigDecimalType.toString(Object value)
           
 PersistentCollection BagType.instantiate(SessionImplementor session, CollectionPersister persister, Serializable key)
           
 PersistentCollection ArrayType.instantiate(SessionImplementor session, CollectionPersister persister, Serializable key)
           
 String ArrayType.toLoggableString(Object value, SessionFactoryImplementor factory)
           
 void ArrayType.replaceElements(Object original, Object target, Object owner, Map copyCache, SessionImplementor session)
           
 Object AnyType.deepCopy(Object value, EntityMode entityMode, SessionFactoryImplementor factory)
           
 boolean AnyType.isSame(Object x, Object y, EntityMode entityMode)
           
 Object AnyType.nullSafeGet(ResultSet rs, String name, SessionImplementor session, Object owner)
           
 Object AnyType.nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)
           
 Object AnyType.hydrate(ResultSet rs, String[] names, SessionImplementor session, Object owner)
           
 Object AnyType.resolve(Object value, SessionImplementor session, Object owner)
           
 Object AnyType.semiResolve(Object value, SessionImplementor session, Object owner)
           
 void AnyType.nullSafeSet(PreparedStatement st, Object value, int index, boolean[] settable, SessionImplementor session)
           
 void AnyType.nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)
           
 String AnyType.toLoggableString(Object value, SessionFactoryImplementor factory)
           
 Object AnyType.fromXMLNode(org.dom4j.Node xml, Mapping factory)
           
 Object AnyType.assemble(Serializable cached, SessionImplementor session, Object owner)
           
 Serializable AnyType.disassemble(Object value, SessionImplementor session, Object owner)
           
 Object AnyType.replace(Object original, Object target, SessionImplementor session, Object owner, Map copyCache)
           
 Object AnyType.getPropertyValue(Object component, int i, SessionImplementor session)
           
 Object[] AnyType.getPropertyValues(Object component, SessionImplementor session)
           
 void AnyType.setPropertyValues(Object component, Object[] values, EntityMode entityMode)
           
 boolean AnyType.isModified(Object old, Object current, SessionImplementor session)
           
 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, SessionImplementor session)
           
 boolean AbstractType.isSame(Object x, Object y, EntityMode entityMode)
           
 Object[] AbstractComponentType.getPropertyValues(Object component, SessionImplementor session)
           
 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)
           
 

Uses of HibernateException in org.hibernate.usertype
 

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

Uses of HibernateException in org.hibernate.util
 

Methods in org.hibernate.util that throw HibernateException
static InputStream ConfigHelper.getConfigStream(String path)
          Open an InputStream to the URL represented by the incoming path.
static Reader ConfigHelper.getConfigStreamReader(String path)
          Open an Reader to the URL represented by the incoming path.
static Properties ConfigHelper.getConfigProperties(String path)
          Loads a properties instance based on the data at the incoming config location.