Uses of Class net.sf.hibernate.HibernateException (Hibernate API Documentation) - Hibernate 2.1.8 正式版 API 英文文档

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV NEXT

FRAMES NO FRAMES

Uses of Class
net.sf.hibernate.HibernateException

Packages that use HibernateException
net.sf.hibernate
net.sf.hibernate.cache
net.sf.hibernate.cfg
net.sf.hibernate.collection
net.sf.hibernate.connection
net.sf.hibernate.dialect
net.sf.hibernate.engine
net.sf.hibernate.exception
net.sf.hibernate.expression
net.sf.hibernate.hql
net.sf.hibernate.id
net.sf.hibernate.impl
net.sf.hibernate.jca
net.sf.hibernate.jmx
net.sf.hibernate.loader
net.sf.hibernate.mapping
net.sf.hibernate.metadata
net.sf.hibernate.persister
net.sf.hibernate.property
net.sf.hibernate.proxy
net.sf.hibernate.tool.hbm2ddl
net.sf.hibernate.transaction
net.sf.hibernate.type
net.sf.hibernate.util
net.sf.hibernate.xml

Uses of HibernateException in net.sf.hibernate

Subclasses of HibernateException in net.sf.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 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
          Throw 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 StaleObjectStateException
          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
          Throw 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 ValidationFailure
          Thrown from Validatable.validate() when an invariant was violated.

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 net.sf.hibernate that throw HibernateException

boolean UserType.equals(Object x, Object y)
          Compare two instances of the class mapped by this type for 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.

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.

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.

Databinder SessionFactory.openDatabinder()
          Create a new databinder.

ClassMetadata SessionFactory.getClassMetadata(Class persistentClass)
          Get the ClassMetadata associated with the given entity class

CollectionMetadata SessionFactory.getCollectionMetadata(String roleName)
          Get the CollectionMetadata associated with the named collection role

Map SessionFactory.getAllClassMetadata()
          Get all ClassMetadata as a Map from Class 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.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(Class theClass, 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 all reachable transient objects, reusing the current identifier values.

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.

void Session.saveOrUpdate(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 transient instance.

void Session.update(Object object, Serializable id)
          Update the persistent state associated with the given identifier.

Object Session.saveOrUpdateCopy(Object object)
          Copy the state of the given object onto the persistent object with the same identifier.

Object Session.saveOrUpdateCopy(Object object, Serializable id)
          Copy the state of the given object onto the persistent object with the given identifier.

void Session.delete(Object object)
          Remove a persistent instance from the datastore.

List Session.find(String query)
          Execute a query.

List Session.find(String query, Object value, Type type)
          Execute a query with bind parameters.

List Session.find(String query, Object[] values, Type[] types)
          Execute a query with bind parameters.

Iterator Session.iterate(String query)
          Execute a query and return the results in an iterator.

Iterator Session.iterate(String query, Object value, Type type)
          Execute a query and return the results in an iterator.

Iterator Session.iterate(String query, Object[] values, Type[] types)
          Execute a query and return the results in an iterator.

Collection Session.filter(Object collection, String filter)
          Apply a filter to a persistent collection.

Collection Session.filter(Object collection, String filter, Object value, Type type)
          Apply a filter to a persistent collection.

Collection Session.filter(Object collection, String filter, Object[] values, Type[] types)
          Apply a filter to a persistent collection.

int Session.delete(String query)
          Delete all objects returned by the query.

int Session.delete(String query, Object value, Type type)
          Delete all objects returned by the query.

int Session.delete(String query, Object[] values, Type[] types)
          Delete all objects returned by the query.

void Session.lock(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.

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.

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

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

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

String Databinder.toGenericXML()
          Output the generic XML representation of the bound objects.

org.w3c.dom.Document Databinder.toGenericDOM()
          Output the generic XML representation of the bound objects as a DOM tree.

String Databinder.toXML()
          Output the custom XML representation of the bound objects.

org.w3c.dom.Document Databinder.toDOM()
          Output the custom XML representation of the bound objects as a DOM tree.

List Criteria.list()
          Get the results.

Object Criteria.uniqueResult()
          Convenience method to return a single instance that matches the query, or null if the query returns no results.

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

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

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.

Uses of HibernateException in net.sf.hibernate.cache

Subclasses of HibernateException in net.sf.hibernate.cache

class CacheException
Something went wrong in the cache

Methods in net.sf.hibernate.cache that throw HibernateException

boolean UpdateTimestampsCache.isUpToDate(Set spaces, Long timestamp)


void TransactionalCache.setMinimalPuts(boolean minimalPuts)


QueryCache StandardQueryCacheFactory.getQueryCache(String regionName, CacheProvider provider, UpdateTimestampsCache updateTimestampsCache, Properties props)


void StandardQueryCache.put(QueryKey key, Type[] returnTypes, List result, SessionImplementor session)


List StandardQueryCache.get(QueryKey key, Type[] returnTypes, Set spaces, SessionImplementor session)


protected boolean StandardQueryCache.isUpToDate(Set spaces, Long timestamp)


void ReadWriteCache.setMinimalPuts(boolean minimalPuts)


void ReadOnlyCache.setMinimalPuts(boolean minimalPuts)


QueryCache QueryCacheFactory.getQueryCache(String regionName, CacheProvider provider, UpdateTimestampsCache updateTimestampsCache, Properties props)


void QueryCache.put(QueryKey key, Type[] returnTypes, List result, SessionImplementor session)


List QueryCache.get(QueryKey key, Type[] returnTypes, Set spaces, SessionImplementor session)


void NonstrictReadWriteCache.setMinimalPuts(boolean minimalPuts)


void CacheConcurrencyStrategy.setMinimalPuts(boolean minimalPuts)
          Enable "minimal puts" mode for this cache

Constructors in net.sf.hibernate.cache that throw HibernateException

UpdateTimestampsCache(CacheProvider provider, Properties props)

StandardQueryCache(CacheProvider provider, Properties props, UpdateTimestampsCache updateTimestampsCache, String regionName)

Uses of HibernateException in net.sf.hibernate.cfg

Methods in net.sf.hibernate.cfg that throw HibernateException

static Settings SettingsFactory.buildSettings(Properties properties)


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)


protected void Configuration.configureCaches(Settings settings)


protected Settings Configuration.buildSettings()
          Create an object-oriented view of the configuration properties

Uses of HibernateException in net.sf.hibernate.collection

Methods in net.sf.hibernate.collection that throw HibernateException

Serializable SortedSet.snapshot(BasicCollectionPersister persister)


Serializable SortedMap.snapshot(BasicCollectionPersister persister)


protected Serializable Set.snapshot(CollectionPersister persister)


Collection Set.getOrphans(Serializable snapshot)


boolean Set.equalsSnapshot(Type elementType)


void Set.initializeFromCache(CollectionPersister persister, Serializable disassembled, Object owner)


void Set.writeTo(PreparedStatement st, CollectionPersister persister, Object entry, int i, boolean writeOrder)


Object Set.readFrom(ResultSet rs, CollectionPersister persister, Object owner)


Serializable Set.disassemble(CollectionPersister persister)


Iterator Set.getDeletes(Type elemType)


boolean Set.needsInserting(Object entry, int i, Type elemType)


boolean PersistentCollection.setCurrentSession(SessionImplementor session)
          Associate the collection with the given session.

abstract void PersistentCollection.initializeFromCache(CollectionPersister persister, Serializable disassembled, Object owner)
          Read the state of the collection from a disassembled cached value

abstract Object PersistentCollection.readFrom(ResultSet rs, CollectionPersister role, Object owner)
          Read a row from the JDBC result set

abstract void PersistentCollection.writeTo(PreparedStatement st, CollectionPersister role, Object entry, int i, boolean writeOrder)
          Write a row to the JDBC prepared statement

abstract boolean PersistentCollection.equalsSnapshot(Type elementType)
          Does the current state exactly match the snapshot?

protected abstract Serializable PersistentCollection.snapshot(CollectionPersister persister)
          Return a new snapshot of the current state

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

abstract boolean PersistentCollection.needsInserting(Object entry, int i, Type elemType)
          Do we need to insert this element?

abstract boolean PersistentCollection.needsUpdating(Object entry, int i, Type elemType)
          Do we need to update this element?

abstract Iterator PersistentCollection.getDeletes(Type elemType)
          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

abstract Collection PersistentCollection.getOrphans(Serializable snapshot)
          get all "orphaned" elements

protected static Collection PersistentCollection.getOrphans(Collection oldElements, Collection currentElements, SessionImplementor session)


protected int OneToManyPersister.doUpdateRows(Serializable id, PersistentCollection collection, SessionImplementor session)


protected Serializable Map.snapshot(CollectionPersister persister)


Collection Map.getOrphans(Serializable snapshot)


boolean Map.equalsSnapshot(Type elementType)


void Map.writeTo(PreparedStatement st, CollectionPersister persister, Object entry, int i, boolean writeOrder)


Object Map.readFrom(ResultSet rs, CollectionPersister persister, Object owner)


void Map.initializeFromCache(CollectionPersister persister, Serializable disassembled, Object owner)


Serializable Map.disassemble(CollectionPersister persister)


Iterator Map.getDeletes(Type elemType)


boolean Map.needsInserting(Object entry, int i, Type elemType)


boolean Map.needsUpdating(Object entry, int i, Type elemType)


protected Serializable List.snapshot(CollectionPersister persister)


Collection List.getOrphans(Serializable snapshot)


boolean List.equalsSnapshot(Type elementType)


void List.writeTo(PreparedStatement st, CollectionPersister persister, Object entry, int i, boolean writeOrder)


Object List.readFrom(ResultSet rs, CollectionPersister persister, Object owner)


void List.initializeFromCache(CollectionPersister persister, Serializable disassembled, Object owner)


Serializable List.disassemble(CollectionPersister persister)


Iterator List.getDeletes(Type elemType)


boolean List.needsInserting(Object entry, int i, Type elemType)


boolean List.needsUpdating(Object entry, int i, Type elemType)


void IdentifierBag.initializeFromCache(CollectionPersister persister, Serializable disassembled, Object owner)


Serializable IdentifierBag.disassemble(CollectionPersister persister)


boolean IdentifierBag.equalsSnapshot(Type elementType)


Iterator IdentifierBag.getDeletes(Type elemType)


boolean IdentifierBag.needsInserting(Object entry, int i, Type elemType)


boolean IdentifierBag.needsUpdating(Object entry, int i, Type elemType)


Object IdentifierBag.readFrom(ResultSet rs, CollectionPersister persister, Object owner)


protected Serializable IdentifierBag.snapshot(CollectionPersister persister)


Collection IdentifierBag.getOrphans(Serializable snapshot)


void IdentifierBag.preInsert(CollectionPersister persister)


void IdentifierBag.writeTo(PreparedStatement st, CollectionPersister persister, Object entry, int i, boolean writeOrder)


void IdentifierBag.afterRowInsert(CollectionPersister persister, Object entry, int i)


void CollectionPersister.initialize(Serializable key, SessionImplementor session)
          Initialize the given collection with the given key

Object CollectionPersister.readKey(ResultSet rs, SessionImplementor session)
          Read the key from a row of the JDBC ResultSet

Object CollectionPersister.readElement(ResultSet rs, Object owner, SessionImplementor session)
          Read the element from a row of the JDBC ResultSet

Object CollectionPersister.readIndex(ResultSet rs, SessionImplementor session)
          Read the index from a row of the JDBC ResultSet

Object CollectionPersister.readIdentifier(ResultSet rs, SessionImplementor session)
          Read the identifier from a row of the JDBC ResultSet

void CollectionPersister.writeKey(PreparedStatement st, Serializable key, boolean writeOrder, SessionImplementor session)
          Write the key to a JDBC PreparedStatement

void CollectionPersister.writeElement(PreparedStatement st, Object elt, boolean writeOrder, SessionImplementor session)
          Write the element to a JDBC PreparedStatement

void CollectionPersister.writeIndex(PreparedStatement st, Object idx, boolean writeOrder, SessionImplementor session)
          Write the index to a JDBC PreparedStatement

void CollectionPersister.writeIdentifier(PreparedStatement st, Object idx, boolean writeOrder, SessionImplementor session)
          Write the identifier to a JDBC PreparedStatement

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)


Object Bag.readFrom(ResultSet rs, CollectionPersister persister, Object owner)


void Bag.writeTo(PreparedStatement st, CollectionPersister persister, Object entry, int i, boolean writeOrder)


boolean Bag.equalsSnapshot(Type elementType)


protected Serializable Bag.snapshot(CollectionPersister persister)


Collection Bag.getOrphans(Serializable snapshot)


Serializable Bag.disassemble(CollectionPersister persister)


void Bag.initializeFromCache(CollectionPersister persister, Serializable disassembled, Object owner)


Iterator Bag.getDeletes(Type elemType)


boolean Bag.needsInserting(Object entry, int i, Type elemType)


protected Serializable ArrayHolder.snapshot(CollectionPersister persister)


Collection ArrayHolder.getOrphans(Serializable snapshot)


boolean ArrayHolder.equalsSnapshot(Type elementType)


void ArrayHolder.writeTo(PreparedStatement st, CollectionPersister persister, Object entry, int i, boolean writeOrder)


Object ArrayHolder.readFrom(ResultSet rs, CollectionPersister persister, Object owner)


void ArrayHolder.initializeFromCache(CollectionPersister persister, Serializable disassembled, Object owner)


Serializable ArrayHolder.disassemble(CollectionPersister persister)


Iterator ArrayHolder.getDeletes(Type elemType)


boolean ArrayHolder.needsInserting(Object entry, int i, Type elemType)


boolean ArrayHolder.needsUpdating(Object entry, int i, Type elemType)


void AbstractCollectionPersister.initialize(Serializable key, SessionImplementor session)


Object AbstractCollectionPersister.readElement(ResultSet rs, Object owner, SessionImplementor session)


Object AbstractCollectionPersister.readIndex(ResultSet rs, SessionImplementor session)


Object AbstractCollectionPersister.readIdentifier(ResultSet rs, SessionImplementor session)


Object AbstractCollectionPersister.readKey(ResultSet rs, SessionImplementor session)


void AbstractCollectionPersister.writeElement(PreparedStatement st, Object elt, boolean writeOrder, SessionImplementor session)


void AbstractCollectionPersister.writeIndex(PreparedStatement st, Object idx, boolean writeOrder, SessionImplementor session)


void AbstractCollectionPersister.writeIdentifier(PreparedStatement st, Object idx, boolean writeOrder, SessionImplementor session)


void AbstractCollectionPersister.writeKey(PreparedStatement st, Serializable id, boolean writeOrder, SessionImplementor session)


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)

Constructors in net.sf.hibernate.collection that throw HibernateException

SortedSet(SessionImplementor session, CollectionPersister persister, Comparator comparator, Serializable disassembled, Object owner)


SortedMap(SessionImplementor session, CollectionPersister persister, Comparator comparator, Serializable disassembled, Object owner)


ArrayHolder(SessionImplementor session, CollectionPersister persister)

Uses of HibernateException in net.sf.hibernate.connection

Methods in net.sf.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 DBCPConnectionProvider.configure(Properties props)


void DBCPConnectionProvider.close()


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 net.sf.hibernate.dialect

Methods in net.sf.hibernate.dialect that throw HibernateException

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)
          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 net.sf.hibernate.engine

Methods in net.sf.hibernate.engine that throw HibernateException

static Object Versioning.getVersion(Object[] fields, ClassPersister persister)
          Get the version number of the given instance state snapshot

void SessionImplementor.initializeCollection(PersistentCollection collection, boolean writing)
          Initialize the collection (if not already initialized)

PersistentCollection SessionImplementor.getLoadingCollection(CollectionPersister persister, Serializable id, Object resultSetId)


void SessionImplementor.endLoadingCollections(CollectionPersister persister, Object resultSetId)


void SessionImplementor.initializeNonLazyCollections()


Object SessionImplementor.getCollection(String role, Serializable id, Object owner)


Object SessionImplementor.internalLoad(Class persistentClass, Serializable id)
          Load an instance without checking if it was deleted.

Object SessionImplementor.internalLoadOneToOne(Class persistentClass, Serializable id)
          Load an instance without checking if it was deleted.

Object SessionImplementor.immediateLoad(Class persistentClass, Serializable id)
          Load an instance immediately.

Object SessionImplementor.loadByUniqueKey(Class persistentClass, String uniqueKeyPropertyName, Serializable id)
          Load an instance by a unique key that is not the primary key.

void SessionImplementor.postUpdate(Object object, Object[] updatedState, Object nextVersion)
          After actually updating a row, record the fact that the database state has been updated

List SessionImplementor.find(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.filter(Object collection, String filter, QueryParameters queryParameters)
          Execute a filter

Iterator SessionImplementor.iterateFilter(Object collection, String filter, QueryParameters queryParameters)
          Iterate a filter

void SessionImplementor.postHydrate(ClassPersister persister, Serializable id, Object[] values, Object object, LockMode lockMode)
          Register the "hydrated" state of an entity instance, after the first step of 2-phase loading

void SessionImplementor.initializeEntity(Object object)
          Perform the second step of 2-phase load.

Object SessionImplementor.proxyFor(ClassPersister persister, Key key, Object impl)
          Return the existing proxy associated with the given Key, or the second argument (the entity associated with the key) if no proxy exists.

Object SessionImplementor.proxyFor(Object impl)
          Return the existing proxy associated with the given Key, or the second argument (the entity associated with the key) if no proxy exists.

Serializable SessionImplementor.getEntityIdentifierIfNotUnsaved(Object object)
          Return the identifier of the persistent or transient object, or throw an exception if the instance is "unsaved"

boolean SessionImplementor.isSaved(Object object)
          Was this object already saved to the database?

Object SessionImplementor.instantiate(Class clazz, Serializable id)
          Instantiate the entity class, initializing with the given identifier

Collection SessionImplementor.getOrphans(PersistentCollection coll)
          Get the collection orphans (entities which were removed from the collection)

List SessionImplementor.findBySQL(String sqlQuery, String[] aliases, Class[] classes, QueryParameters queryParameters, Collection querySpaces)
          Execute an SQL Query

Object SessionImplementor.copy(Object object, Map copiedAlready)


Type[] SessionFactoryImplementor.getReturnTypes(String queryString)
          Get the return types of a query

QueryCache SessionFactoryImplementor.getQueryCache(String regionName)
          Get a particular named query cache, or the default cache

void QueryParameters.traceParameters(SessionFactoryImplementor factory)


static void Cascades.cascade(SessionImplementor session, ClassPersister 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, ClassPersister persister, Object parent, Cascades.CascadingAction action, int cascadeTo, Object anything)
          Cascade an action from the parent object to all its children

PreparedStatement Batcher.prepareQueryStatement(String sql, boolean scrollable, ScrollMode scrollMode)
          Get a prepared statement for use in loading / querying.

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.

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()).

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

Connection Batcher.openConnection()
          Obtain a JDBC connection

void Batcher.closeConnection(Connection conn)
          Dispose of the JDBC connection

void Batcher.cancelLastQuery()
          Cancel the current query statement

Uses of HibernateException in net.sf.hibernate.exception

Subclasses of HibernateException in net.sf.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 JDBCConnectionException.

class LockAcquisitionException
          Implementation of LockAcquisitionException.

class SQLGrammarException
          Implementation of JDBCException indicating that the SQL sent to the database server was invalid (syntax error, invalid object references, etc).

Methods in net.sf.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 net.sf.hibernate.expression

Methods in net.sf.hibernate.expression that throw HibernateException

String SQLCriterion.toSqlString(SessionFactoryImplementor sessionFactory, Class persistentClass, String alias, Map aliasClasses)


TypedValue[] SQLCriterion.getTypedValues(SessionFactoryImplementor sessionFactory, Class persistentClass, Map aliasClasses)


String SimpleExpression.toSqlString(SessionFactoryImplementor sessionFactory, Class persistentClass, String alias, Map aliasClasses)


TypedValue[] SimpleExpression.getTypedValues(SessionFactoryImplementor sessionFactory, Class persistentClass, Map aliasClasses)


String PropertyExpression.toSqlString(SessionFactoryImplementor sessionFactory, Class persistentClass, String alias, Map aliasClasses)


TypedValue[] PropertyExpression.getTypedValues(SessionFactoryImplementor sessionFactory, Class persistentClass, Map aliasClasses)


String Order.toSqlString(SessionFactoryImplementor sessionFactory, Class persistentClass, String alias)
          Render the SQL fragment

String NullExpression.toSqlString(SessionFactoryImplementor sessionFactory, Class persistentClass, String alias, Map aliasClasses)


TypedValue[] NullExpression.getTypedValues(SessionFactoryImplementor sessionFactory, Class persistentClass, Map aliasClasses)


String NotNullExpression.toSqlString(SessionFactoryImplementor sessionFactory, Class persistentClass, String alias, Map aliasClasses)


TypedValue[] NotNullExpression.getTypedValues(SessionFactoryImplementor sessionFactory, Class persistentClass, Map aliasClasses)


String NotExpression.toSqlString(SessionFactoryImplementor sessionFactory, Class persistentClass, String alias, Map aliasClasses)


TypedValue[] NotExpression.getTypedValues(SessionFactoryImplementor sessionFactory, Class persistentClass, Map aliasClasses)


TypedValue[] LogicalExpression.getTypedValues(SessionFactoryImplementor sessionFactory, Class persistentClass, Map aliasClasses)


String LogicalExpression.toSqlString(SessionFactoryImplementor sessionFactory, Class persistentClass, String alias, Map aliasClasses)


TypedValue[] Junction.getTypedValues(SessionFactoryImplementor sessionFactory, Class persistentClass, Map aliasClasses)


String Junction.toSqlString(SessionFactoryImplementor sessionFactory, Class persistentClass, String alias, Map aliasClasses)


String InExpression.toSqlString(SessionFactoryImplementor sessionFactory, Class persistentClass, String alias, Map aliasClasses)


TypedValue[] InExpression.getTypedValues(SessionFactoryImplementor sessionFactory, Class persistentClass, Map aliasClasses)


String IlikeExpression.toSqlString(SessionFactoryImplementor sessionFactory, Class persistentClass, String alias, Map aliasClasses)


TypedValue[] IlikeExpression.getTypedValues(SessionFactoryImplementor sessionFactory, Class persistentClass, Map aliasClasses)


String Example.toSqlString(SessionFactoryImplementor sessionFactory, Class persistentClass, String alias, Map aliasClasses)


TypedValue[] Example.getTypedValues(SessionFactoryImplementor sessionFactory, Class persistentClass, Map aliasClasses)


protected void Example.addComponentTypedValues(String path, Object component, AbstractComponentType type, List list)


protected void Example.appendPropertyCondition(String propertyName, Object propertyValue, Class persistentClass, String alias, Map aliasClasses, SessionFactoryImplementor sessionFactory, StringBuffer buf)


protected void Example.appendComponentCondition(String path, Object component, AbstractComponentType type, Class persistentClass, String alias, Map aliasClasses, SessionFactoryImplementor sessionFactory, StringBuffer buf)


String Criterion.toSqlString(SessionFactoryImplementor sessionFactory, Class persistentClass, String alias, Map aliasClasses)
          Render the SQL fragment

TypedValue[] Criterion.getTypedValues(SessionFactoryImplementor sessionFactory, Class persistentClass, Map aliasClasses)
          Return typed values for all parameters in the rendered SQL fragment

String BetweenExpression.toSqlString(SessionFactoryImplementor sessionFactory, Class persistentClass, String alias, Map aliasClasses)


TypedValue[] BetweenExpression.getTypedValues(SessionFactoryImplementor sessionFactory, Class persistentClass, Map aliasClasses)


protected static String[] AbstractCriterion.getColumns(SessionFactoryImplementor sessionFactory, Class persistentClass, String property, String alias, Map aliasClasses)


protected static Type AbstractCriterion.getType(SessionFactoryImplementor sessionFactory, Class persistentClass, String property, Map aliasClasses)


protected static TypedValue AbstractCriterion.getTypedValue(SessionFactoryImplementor sessionFactory, Class persistentClass, String property, Object value, Map aliasClasses)
          Get the a typed value for the given property value.

Uses of HibernateException in net.sf.hibernate.hql

Methods in net.sf.hibernate.hql that throw HibernateException

Object QueryTranslator.loadSingleRow(ResultSet resultSet, SessionImplementor session, QueryParameters queryParameters, boolean returnProxies)


protected int QueryTranslator.bindNamedParameters(PreparedStatement ps, Map namedParams, int start, SessionImplementor session)


List QueryTranslator.list(SessionImplementor session, QueryParameters queryParameters)


Iterator QueryTranslator.iterate(QueryParameters queryParameters, SessionImplementor session)
          Return the query results as an iterator

ScrollableResults QueryTranslator.scroll(QueryParameters queryParameters, SessionImplementor session)
          Return the query results, as an instance of ScrollableResults

protected Object QueryTranslator.getResultColumnOrRow(Object[] row, ResultSet rs, SessionImplementor session)

Uses of HibernateException in net.sf.hibernate.id

Subclasses of HibernateException in net.sf.hibernate.id

class IdentifierGenerationException
Thrown by IdentifierGenerator implementation class when ID generation fails.

Methods in net.sf.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.sqlDropString(Dialect dialect)


String[] PersistentIdentifierGenerator.sqlCreateStrings(Dialect dialect)
          The SQL required to create the underlying database objects.

String PersistentIdentifierGenerator.sqlDropString(Dialect dialect)
          The SQL required to remove the underlying database objects.

Serializable IncrementGenerator.generate(SessionImplementor session, Object object)


Serializable IdentityGenerator.generate(SessionImplementor s, Object obj)


Serializable IdentifierGenerator.generate(SessionImplementor session, Object object)
          Generate a new identifier.

Serializable ForeignGenerator.generate(SessionImplementor session, Object object)


Serializable Assigned.generate(SessionImplementor session, Object obj)

Uses of HibernateException in net.sf.hibernate.impl

Methods in net.sf.hibernate.impl that throw HibernateException

List SQLQueryImpl.list()


Iterator SQLQueryImpl.iterate()


ScrollableResults SQLQueryImpl.scroll()


ScrollableResults SQLQueryImpl.scroll(ScrollMode scrollMode)


Type[] SQLQueryImpl.getReturnTypes()


Connection SessionImpl.close()


LockMode SessionImpl.getCurrentLockMode(Object object)


Serializable SessionImpl.save(Object obj)
          Save a transient object.

void SessionImpl.save(Object obj, Serializable id)
          Save a transient object with a manually assigned ID.

void SessionImpl.delete(Object object)
          Delete a persistent object

void SessionImpl.update(Object obj)


void SessionImpl.saveOrUpdate(Object obj)


void SessionImpl.update(Object obj, Serializable id)


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.find(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)


void SessionImpl.lock(Object object, LockMode lockMode)


Object SessionImpl.instantiate(Class clazz, Serializable id)


Object SessionImpl.instantiate(ClassPersister persister, Serializable id)
          give the interceptor an opportunity to override the default instantiation

Object SessionImpl.narrowProxy(Object proxy, ClassPersister persister, Key key, Object object)
          If the existing proxy is insufficiently "narrow" (derived), instantiate a new proxy and overwrite the registration of the old one.

Object SessionImpl.proxyFor(ClassPersister persister, Key key, Object impl)
          Grab the existing proxy for an instance, if one exists.

Object SessionImpl.proxyFor(Object impl)


void SessionImpl.postHydrate(ClassPersister persister, Serializable id, Object[] values, Object object, LockMode lockMode)
          Add the "hydrated state" (an array) of an uninitialized entity to the session.

void SessionImpl.load(Object object, Serializable id)


Object SessionImpl.load(Class clazz, Serializable id)


Object SessionImpl.get(Class clazz, Serializable id)


Object SessionImpl.immediateLoad(Class clazz, Serializable id)
          Load the data for the object with the specified id into a newly created object.

Object SessionImpl.internalLoadOneToOne(Class clazz, Serializable id)
          Return the object with the specified id or null if no row with that id exists.

Object SessionImpl.internalLoad(Class clazz, Serializable id)
          Return the object with the specified id or throw exception if no row with that id exists.

Object SessionImpl.load(Class clazz, Serializable id, LockMode lockMode)


Object SessionImpl.get(Class clazz, Serializable id, LockMode lockMode)


void SessionImpl.refresh(Object object)


void SessionImpl.refresh(Object obj, LockMode lockMode)


void SessionImpl.initializeEntity(Object object)
          After processing a JDBC result set, we "resolve" all the associations between the entities which were instantiated and had their state "hydrated" into an array

Transaction SessionImpl.beginTransaction()


void SessionImpl.flush()


boolean SessionImpl.isDirty()


void SessionImpl.postUpdate(Object obj, Object[] updatedState, Object nextVersion)


Serializable SessionImpl.getIdentifier(Object object)


boolean SessionImpl.isSaved(Object object)


Serializable SessionImpl.getEntityIdentifierIfNotUnsaved(Object object)
          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.

PersistentCollection SessionImpl.getLoadingCollection(CollectionPersister persister, Serializable id, Object resultSetId)


void SessionImpl.endLoadingCollections(CollectionPersister persister, Object resultSetId)


void SessionImpl.initializeNonLazyCollections()


Collection SessionImpl.getOrphans(PersistentCollection coll)


void SessionImpl.initializeCollection(PersistentCollection collection, boolean writing)
          called by a collection that wants to initialize itself

Connection SessionImpl.connection()


Connection SessionImpl.disconnect()


void SessionImpl.reconnect()


void SessionImpl.reconnect(Connection conn)


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.filter(Object collection, String filter, QueryParameters queryParameters)


Iterator SessionImpl.iterateFilter(Object collection, String filter, QueryParameters queryParameters)


List SessionImpl.find(CriteriaImpl criteria)


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)

List SessionImpl.findBySQL(String sqlQuery, String[] aliases, Class[] classes, QueryParameters queryParameters, Collection querySpaces)


Object SessionImpl.loadByUniqueKey(Class clazz, String uniqueKeyPropertyName, Serializable id)


void SessionImpl.replicate(Object obj, ReplicationMode replicationMode)


Object SessionImpl.getCollection(String role, Serializable id, Object owner)
          instantiate a collection wrapper (called when loading an object)

void SessionImpl.cancelQuery()


Object SessionImpl.saveOrUpdateCopy(Object object)


Object SessionImpl.copy(Object object, Map copiedAlready)


Object SessionImpl.doCopy(Object object, Serializable id, Map copiedAlready)


Object SessionImpl.saveOrUpdateCopy(Object object, Serializable id)


void SessionImpl.CollectionEntry.initSnapshot(PersistentCollection collection, CollectionPersister persister)


Session SessionFactoryImpl.openSession(Interceptor interceptor)


Session SessionFactoryImpl.openSession()


Databinder SessionFactoryImpl.openDatabinder()


Type[] SessionFactoryImpl.getReturnTypes(String queryString)


ClassMetadata SessionFactoryImpl.getClassMetadata(Class persistentClass)


CollectionMetadata SessionFactoryImpl.getCollectionMetadata(String roleName)


Map SessionFactoryImpl.getAllClassMetadata()


Map SessionFactoryImpl.getAllCollectionMetadata()


void SessionFactoryImpl.close()
          Closes the session factory, releasing all held resources.

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)


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


String Printer.toString(Object entity)


String Printer.toString(Type[] types, Object[] values)


String Printer.toString(Map namedTypedValues)


void Printer.toString(Iterator iter)


void NonBatchingBatcher.addToBatch(int expectedRowCount)


protected void NonBatchingBatcher.doExecuteBatch(PreparedStatement ps)


Iterator FilterImpl.iterate()


List FilterImpl.list()


ScrollableResults FilterImpl.scroll()


List CriteriaImpl.list()


Criteria CriteriaImpl.createAlias(String associationPath, String alias)


Class CriteriaImpl.getClassForPath(String rootAlias, String associationPath)


Criteria CriteriaImpl.createCriteria(String associationPath)


Object CriteriaImpl.uniqueResult()


Criteria CriteriaImpl.createCriteria(String associationPath, String alias)


Criteria CriteriaImpl.Subcriteria.createAlias(String associationPath, String alias)


Criteria CriteriaImpl.Subcriteria.createCriteria(String associationPath)


List CriteriaImpl.Subcriteria.list()


Object CriteriaImpl.Subcriteria.uniqueResult()


Criteria CriteriaImpl.Subcriteria.setFetchMode(String associationPath, FetchMode mode)


Criteria CriteriaImpl.Subcriteria.createCriteria(String associationPath, String alias)


Object[] CacheEntry.assemble(Object instance, Serializable id, ClassPersister persister, Interceptor interceptor, SessionImplementor session)


void BatchingBatcher.addToBatch(int expectedRowCount)


protected void BatchingBatcher.doExecuteBatch(PreparedStatement ps)


PreparedStatement BatcherImpl.prepareStatement(String sql)


PreparedStatement BatcherImpl.prepareStatement(String sql, boolean getGeneratedKeys)


PreparedStatement BatcherImpl.prepareQueryStatement(String sql, boolean scrollable, ScrollMode scrollMode)


PreparedStatement BatcherImpl.prepareBatchStatement(String sql)


void BatcherImpl.executeBatch()


protected abstract void BatcherImpl.doExecuteBatch(PreparedStatement ps)


Connection BatcherImpl.openConnection()


void BatcherImpl.closeConnection(Connection conn)


void BatcherImpl.cancelLastQuery()


protected void AbstractQueryImpl.verifyParameters()


Query AbstractQueryImpl.setParameter(int position, Object val)


Query AbstractQueryImpl.setParameter(String name, Object val)


Type[] AbstractQueryImpl.getReturnTypes()


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

Constructors in net.sf.hibernate.impl that throw HibernateException

SessionFactoryImpl(Configuration cfg, Settings settings)


IteratorImpl(ResultSet rs, PreparedStatement ps, SessionImplementor sess, Type[] types, String[][] columnNames, Class holderClass)


CacheEntry(Object object, ClassPersister persister, SessionImplementor session)

Uses of HibernateException in net.sf.hibernate.jca

Methods in net.sf.hibernate.jca that throw HibernateException

void JCASessionImpl.flush()


Connection JCASessionImpl.connection()


Connection JCASessionImpl.disconnect()


void JCASessionImpl.reconnect()


void JCASessionImpl.reconnect(Connection connection)


Connection JCASessionImpl.close()


Serializable JCASessionImpl.getIdentifier(Object object)


Object JCASessionImpl.load(Class theClass, Serializable id, LockMode lockMode)


Object JCASessionImpl.load(Class theClass, Serializable id)


void JCASessionImpl.load(Object object, Serializable id)


Serializable JCASessionImpl.save(Object object)


void JCASessionImpl.save(Object object, Serializable id)


void JCASessionImpl.saveOrUpdate(Object object)


void JCASessionImpl.update(Object object)


void JCASessionImpl.update(Object object, Serializable id)


void JCASessionImpl.delete(Object object)


List JCASessionImpl.find(String query)


List JCASessionImpl.find(String query, Object value, Type type)


List JCASessionImpl.find(String query, Object[] values, Type[] types)


Iterator JCASessionImpl.iterate(String query)


Iterator JCASessionImpl.iterate(String query, Object value, Type type)


Iterator JCASessionImpl.iterate(String query, Object[] values, Type[] types)


Collection JCASessionImpl.filter(Object collection, String filter)


Collection JCASessionImpl.filter(Object collection, String filter, Object value, Type type)


Collection JCASessionImpl.filter(Object collection, String filter, Object[] values, Type[] types)


int JCASessionImpl.delete(String query)


int JCASessionImpl.delete(String query, Object value, Type type)


int JCASessionImpl.delete(String query, Object[] values, Type[] types)


void JCASessionImpl.lock(Object object, LockMode lockMode)


void JCASessionImpl.refresh(Object object)


LockMode JCASessionImpl.getCurrentLockMode(Object object)


Transaction JCASessionImpl.beginTransaction()


Query JCASessionImpl.createQuery(String queryString)


Query JCASessionImpl.createFilter(Object collection, String queryString)


Query JCASessionImpl.getNamedQuery(String queryName)


void JCASessionImpl.refresh(Object object, LockMode lockMode)


void JCASessionImpl.evict(Object object)


Object JCASessionImpl.get(Class clazz, Serializable id, LockMode lockMode)


Object JCASessionImpl.get(Class clazz, Serializable id)


void JCASessionImpl.replicate(Object object, ReplicationMode mode)


void JCASessionImpl.cancelQuery()


Object JCASessionImpl.saveOrUpdateCopy(Object object)


Object JCASessionImpl.saveOrUpdateCopy(Object object, Serializable id)


boolean JCASessionImpl.isDirty()


void JCASessionFactoryImpl.close()


Map JCASessionFactoryImpl.getAllClassMetadata()


Map JCASessionFactoryImpl.getAllCollectionMetadata()


ClassMetadata JCASessionFactoryImpl.getClassMetadata(Class persistentClass)


CollectionMetadata JCASessionFactoryImpl.getCollectionMetadata(String roleName)


Databinder JCASessionFactoryImpl.openDatabinder()


Session JCASessionFactoryImpl.openSession()


Session JCASessionFactoryImpl.openSession(Interceptor interceptor)


void JCASessionFactoryImpl.evict(Class persistentClass, Serializable id)


void JCASessionFactoryImpl.evict(Class persistentClass)


void JCASessionFactoryImpl.evictCollection(String roleName, Serializable id)


void JCASessionFactoryImpl.evictCollection(String roleName)


void JCASessionFactoryImpl.evictQueries()


void JCASessionFactoryImpl.evictQueries(String cacheRegion)

Constructors in net.sf.hibernate.jca that throw HibernateException

JCASessionFactoryImpl(ManagedConnectionFactoryImpl managedFactory, javax.resource.spi.ConnectionManager cxManager)

Uses of HibernateException in net.sf.hibernate.jmx

Methods in net.sf.hibernate.jmx that throw HibernateException

Session SessionFactoryStub.openSession()


Databinder SessionFactoryStub.openDatabinder()


ClassMetadata SessionFactoryStub.getClassMetadata(Class persistentClass)


CollectionMetadata SessionFactoryStub.getCollectionMetadata(String roleName)


Session SessionFactoryStub.openSession(Interceptor interceptor)


Map SessionFactoryStub.getAllClassMetadata()


Map SessionFactoryStub.getAllCollectionMetadata()


void SessionFactoryStub.close()


void SessionFactoryStub.evict(Class persistentClass, Serializable id)


void SessionFactoryStub.evict(Class persistentClass)


void SessionFactoryStub.evictCollection(String roleName, Serializable id)


void SessionFactoryStub.evictCollection(String roleName)


void SessionFactoryStub.evictQueries()


void SessionFactoryStub.evictQueries(String cacheRegion)


void HibernateServiceMBean.start()
          Create the SessionFactory and bind to the jndi name on startup

void HibernateServiceMBean.createSchema()
          Export create DDL to the database

void HibernateServiceMBean.dropSchema()
          Export drop DDL to the database

void HibernateService.start()


void HibernateService.dropSchema()


void HibernateService.createSchema()

Uses of HibernateException in net.sf.hibernate.loader

Methods in net.sf.hibernate.loader that throw HibernateException

Object UniqueEntityLoader.load(SessionImplementor session, Serializable id, Object optionalObject)
          Load an entity instance.

List SQLLoader.list(SessionImplementor session, QueryParameters queryParameters)


protected Object SQLLoader.getResultColumnOrRow(Object[] row, ResultSet rs, SessionImplementor session)


protected int SQLLoader.bindNamedParameters(PreparedStatement ps, Map namedParams, int start, SessionImplementor session)


Object SimpleEntityLoader.load(SessionImplementor session, Serializable id, Object object)


protected Object SimpleEntityLoader.getResultColumnOrRow(Object[] row, ResultSet rs, SessionImplementor session)


void OneToManyLoader.initialize(Serializable id, SessionImplementor session)


protected String Loader.applyLocks(String sql, Map lockModes, Dialect dialect)
          Append FOR UPDATE OF clause, if necessary.

protected 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(String sql, QueryParameters queryParameters, boolean scroll, SessionImplementor session)
          Obtain a PreparedStatement with all parameters pre-bound.

protected ResultSet Loader.getResultSet(PreparedStatement st, 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, Serializable id, Type identifierType, Object optionalObject, Serializable optionalIdentifier)
          Called by subclasses that load entities

protected List Loader.loadEntityBatch(SessionImplementor session, Serializable[] ids, Type idType, Object optionalObject, Serializable optionalID)
          Called by subclasses that batch load entities

protected void Loader.loadCollection(SessionImplementor session, Serializable id, Type type)
          Called by subclasses that load collections

protected void Loader.loadCollectionBatch(SessionImplementor session, Serializable[] ids, 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

Object EntityLoader.load(SessionImplementor session, Serializable id, Object optionalObject)


Object EntityLoader.loadByUniqueKey(SessionImplementor session, Serializable id)


protected Object EntityLoader.getResultColumnOrRow(Object[] row, ResultSet rs, SessionImplementor session)


List CriteriaLoader.list(SessionImplementor session)


protected Object CriteriaLoader.getResultColumnOrRow(Object[] row, ResultSet rs, SessionImplementor session)


void CollectionLoader.initialize(Serializable id, SessionImplementor session)


void CollectionInitializer.initialize(Serializable id, SessionImplementor session)
          Initialize the given collection

Object BatchingEntityLoader.load(SessionImplementor session, Serializable id, Object optionalObject)


void BatchingCollectionInitializer.initialize(Serializable id, SessionImplementor session)

Constructors in net.sf.hibernate.loader that throw HibernateException

SQLLoader(String[] aliases, SQLLoadable[] persisters, SessionFactoryImplementor factory, String sqlQuery, Collection additionalQuerySpaces)

CriteriaLoader(OuterJoinLoadable persister, SessionFactoryImplementor factory, CriteriaImpl criteria)

Uses of HibernateException in net.sf.hibernate.mapping

Methods in net.sf.hibernate.mapping that throw HibernateException

Iterator Table.sqlAlterStrings(Dialect dialect, Mapping p, TableMetadata tableInfo, String defaultSchema)


String Table.sqlCreateString(Dialect dialect, Mapping p, String defaultSchema)


String RelationalModel.sqlCreateString(Dialect dialect, Mapping p, String defaultSchema)


String Index.sqlCreateString(Dialect dialect, Mapping mapping, String defaultSchema)


String Column.getSqlType(Dialect dialect, Mapping mapping)

Uses of HibernateException in net.sf.hibernate.metadata

Methods in net.sf.hibernate.metadata that throw HibernateException

Object ClassMetadata.instantiate(Serializable id)
          Create a class instance initialized with the given identifier

Type ClassMetadata.getPropertyType(String propertyName)
          Get the type of a particular (named) property

Object ClassMetadata.getPropertyValue(Object object, String propertyName)
          Get the value of a particular (named) property

void ClassMetadata.setPropertyValue(Object object, String propertyName, Object value)
          Set the value of a particular (named) property

Object[] ClassMetadata.getPropertyValues(Object entity)
          Return the values of the mapped properties of the object

void ClassMetadata.setPropertyValues(Object object, Object[] values)
          Set the given values to the mapped properties of the given object

Serializable ClassMetadata.getIdentifier(Object entity)
          Get the identifier of an instance (throw an exception if no identifier property)

void ClassMetadata.setIdentifier(Object object, Serializable id)
          Set the identifier of an instance (or do nothing if no identifier property)

Object ClassMetadata.getVersion(Object object)
          Get the version number (or timestamp) from the object's version property (or return null if not versioned)

Uses of HibernateException in net.sf.hibernate.persister

Methods in net.sf.hibernate.persister that throw HibernateException

Object UniqueKeyLoadable.loadByUniqueKey(String propertyName, Serializable uniqueKey, SessionImplementor session)
          Load an instance of the persistent class, by a unique key other than the primary key.

static ClassPersister PersisterFactory.createClassPersister(PersistentClass model, SessionFactoryImplementor factory)


static CollectionPersister PersisterFactory.createCollectionPersister(Configuration cfg, Collection model, SessionFactoryImplementor factory)


protected int NormalizedEntityPersister.dehydrate(Serializable id, Object[] fields, boolean[] includeProperty, PreparedStatement[] statements, SessionImplementor session)
          Marshall the fields of a persistent instance to a prepared statement

Object NormalizedEntityPersister.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

Serializable NormalizedEntityPersister.insert(Object[] fields, Object object, SessionImplementor session)


void NormalizedEntityPersister.insert(Serializable id, Object[] fields, Object object, SessionImplementor session)


void NormalizedEntityPersister.insert(Serializable id, Object[] fields, boolean[] notNull, String[] sql, Object object, SessionImplementor session)
          Persist an object

Serializable NormalizedEntityPersister.insert(Object[] fields, boolean[] notNull, String[] sql, Object object, SessionImplementor session)
          Persist an object, using a natively generated identifier

void NormalizedEntityPersister.delete(Serializable id, Object version, Object object, SessionImplementor session)
          Delete an object

void NormalizedEntityPersister.update(Serializable id, Object[] fields, int[] dirtyFields, Object[] oldFields, Object oldVersion, Object object, SessionImplementor session)
          Update an object

protected void NormalizedEntityPersister.update(Serializable id, Object[] fields, boolean[] includeProperty, boolean[] includeTable, Object oldVersion, Object object, String[] sql, SessionImplementor session)


protected int EntityPersister.dehydrate(Serializable id, Object[] fields, boolean[] includeProperty, PreparedStatement st, SessionImplementor session)
          Marshall the fields of a persistent instance to a prepared statement

Object EntityPersister.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

Serializable EntityPersister.insert(Object[] fields, Object object, SessionImplementor session)


void EntityPersister.insert(Serializable id, Object[] fields, Object object, SessionImplementor session)


void EntityPersister.insert(Serializable id, Object[] fields, boolean[] notNull, String sql, Object object, SessionImplementor session)
          Persist an object

Serializable EntityPersister.insert(Object[] fields, boolean[] notNull, String sql, Object object, SessionImplementor session)
          Persist an object, using a natively generated identifier

void EntityPersister.delete(Serializable id, Object version, Object object, SessionImplementor session)
          Delete an object

void EntityPersister.update(Serializable id, Object[] fields, int[] dirtyFields, Object[] oldFields, Object oldVersion, Object object, SessionImplementor session)
          Update an object

protected void EntityPersister.update(Serializable id, Object[] fields, Object[] oldFields, boolean[] includeProperty, Object oldVersion, Object object, String sql, SessionImplementor session)


Object ClassPersister.createProxy(Serializable id, SessionImplementor session)
          Create a new proxy instance

boolean ClassPersister.isUnsaved(Object object)
          Is this a new transient instance?

void ClassPersister.setPropertyValues(Object object, Object[] values)
          Set the given values to the mapped properties of the given object

Object[] ClassPersister.getPropertyValues(Object object)
          Return the values of the mapped properties of the object

void ClassPersister.setPropertyValue(Object object, int i, Object value)
          Set the value of a particular property

Object ClassPersister.getPropertyValue(Object object, int i)
          Get the value of a particular property

Object ClassPersister.getPropertyValue(Object object, String propertyName)
          Get the value of a particular property

int[] ClassPersister.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[] ClassPersister.findModified(Object[] old, Object[] current, Object object, SessionImplementor session)
          Compare the state of an instance to the current database state

Serializable ClassPersister.getIdentifier(Object object)
          Get the identifier of an instance (throw an exception if no identifier property)

void ClassPersister.setIdentifier(Object object, Serializable id)
          Set the identifier of an instance (or do nothing if no identifier property)

Object ClassPersister.getVersion(Object object)
          Get the version number (or timestamp) from the object's version property (or return null if not versioned)

Object ClassPersister.instantiate(Serializable id)
          Create a class instance initialized with the given identifier

IdentifierGenerator ClassPersister.getIdentifierGenerator()
          Return the IdentifierGenerator for the class

Object ClassPersister.load(Serializable id, Object optionalObject, LockMode lockMode, SessionImplementor session)
          Load an instance of the persistent class.

void ClassPersister.lock(Serializable id, Object version, Object object, LockMode lockMode, SessionImplementor session)
          Do a version check (optional operation)

void ClassPersister.insert(Serializable id, Object[] fields, Object object, SessionImplementor session)
          Persist an instance

Serializable ClassPersister.insert(Object[] fields, Object object, SessionImplementor session)
          Persist an instance, using a natively generated identifier (optional operation)

void ClassPersister.delete(Serializable id, Object version, Object object, SessionImplementor session)
          Delete a persistent instance

void ClassPersister.update(Serializable id, Object[] fields, int[] dirtyFields, Object[] oldFields, Object oldVersion, Object object, SessionImplementor session)
          Update a persistent instance

Object[] ClassPersister.getCurrentPersistentState(Serializable id, Object version, SessionImplementor session)
          Get the current database state of the object, in a "hydrated" form, without resolving identifiers

Object ClassPersister.getCurrentVersion(Serializable id, SessionImplementor session)
          Get the current version of the object, or return null if there is no row for the given identifier.

void AbstractEntityPersister.setPropertyValues(Object object, Object[] values)
          Set the given values to the mapped properties of the given object

Object[] AbstractEntityPersister.getPropertyValues(Object object)
          Return the values of the mapped properties of the object

Object AbstractEntityPersister.getPropertyValue(Object object, int i)
          Get the value of the numbered property

void AbstractEntityPersister.setPropertyValue(Object object, int i, Object value)
          Set the value of the numbered property

int[] AbstractEntityPersister.findDirty(Object[] x, Object[] y, Object object, SessionImplementor session)
          Determine if the given field values are dirty

int[] AbstractEntityPersister.findModified(Object[] old, Object[] current, Object object, SessionImplementor session)
          Determine if the given field values are dirty

Serializable AbstractEntityPersister.getIdentifier(Object object)


Object AbstractEntityPersister.getVersion(Object object)


void AbstractEntityPersister.setIdentifier(Object object, Serializable id)


Object AbstractEntityPersister.instantiate(Serializable id)
          Return a new instance initialized with the given identifier

boolean AbstractEntityPersister.isUnsaved(Object object)


IdentifierGenerator AbstractEntityPersister.getIdentifierGenerator()


protected void AbstractEntityPersister.check(int rows, Serializable id)


Object AbstractEntityPersister.getPropertyValue(Object object, String propertyName)


void AbstractEntityPersister.setPropertyValue(Object object, String propertyName, Object value)


Object AbstractEntityPersister.loadByUniqueKey(String propertyName, Serializable uniqueKey, SessionImplementor session)


Object AbstractEntityPersister.getCurrentVersion(Serializable id, SessionImplementor session)
          Retrieve the version number

void AbstractEntityPersister.lock(Serializable id, Object version, Object object, LockMode lockMode, SessionImplementor session)
          Do a version check

protected Serializable AbstractEntityPersister.getGeneratedIdentity(Object object, SessionImplementor session, ResultSet rs)
          Get the generated identifier when using identity columns

Object[] AbstractEntityPersister.getCurrentPersistentState(Serializable id, Object version, SessionImplementor session)


Object AbstractEntityPersister.createProxy(Serializable id, SessionImplementor session)

Constructors in net.sf.hibernate.persister that throw HibernateException

NormalizedEntityPersister(PersistentClass model, SessionFactoryImplementor factory)


EntityPersister(PersistentClass model, SessionFactoryImplementor factory)


AbstractEntityPersister(PersistentClass model, SessionFactoryImplementor factory)

Uses of HibernateException in net.sf.hibernate.property

Methods in net.sf.hibernate.property that throw HibernateException

void Setter.set(Object target, Object value)
          Set the property value from the given instance

Object Getter.get(Object target)
          Get the property value from the given instance

Object DirectPropertyAccessor.DirectGetter.get(Object target)


void DirectPropertyAccessor.DirectSetter.set(Object target, Object value)


void BasicPropertyAccessor.BasicSetter.set(Object target, Object value)


Object BasicPropertyAccessor.BasicGetter.get(Object target)

Uses of HibernateException in net.sf.hibernate.proxy

Methods in net.sf.hibernate.proxy that throw HibernateException

void ProxyFactory.postInstantiate(Class persistentClass, Set interfaces, Method getIdentifierMethod, Method setIdentifierMethod)
          Called immediately after instantiation

HibernateProxy ProxyFactory.getProxy(Serializable id, SessionImplementor session)
          Create a new proxy

void LazyInitializer.initialize()


Object LazyInitializer.getImplementation(SessionImplementor s)
          Return the underlying persistent object in the given Session, or null

static Serializable HibernateProxyHelper.getIdentifier(Object object, ClassPersister persister)
          Get the identifier value of an instance or proxy

void CGLIBProxyFactory.postInstantiate(Class persistentClass, Set interfaces, Method getIdentifierMethod, Method setIdentifierMethod)


HibernateProxy CGLIBProxyFactory.getProxy(Serializable id, SessionImplementor session)


static HibernateProxy CGLIBLazyInitializer.getProxy(net.sf.cglib.proxy.Factory factory, Class persistentClass, Class[] interfaces, Method getIdentifierMethod, Method setIdentifierMethod, Serializable id, SessionImplementor session)


static net.sf.cglib.proxy.Factory CGLIBLazyInitializer.getProxyFactory(Class persistentClass, Class[] interfaces)

Uses of HibernateException in net.sf.hibernate.tool.hbm2ddl

Methods in net.sf.hibernate.tool.hbm2ddl that throw HibernateException

TableMetadata DatabaseMetadata.getTableMetadata(String name, String schema, String catalog)

boolean DatabaseMetadata.isTable(Object key)

Constructors in net.sf.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 net.sf.hibernate.transaction

Methods in net.sf.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(SessionImplementor session)
          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(SessionImplementor session)


void JTATransaction.commit()


void JTATransaction.rollback()


void JTATransaction.begin(InitialContext context, String utName, TransactionManager transactionManager)


TransactionManager JOTMTransactionManagerLookup.getTransactionManager(Properties props)


TransactionManager JOnASTransactionManagerLookup.getTransactionManager(Properties props)


TransactionManager JNDITransactionManagerLookup.getTransactionManager(Properties props)


Transaction JDBCTransactionFactory.beginTransaction(SessionImplementor session)


void JDBCTransactionFactory.configure(Properties props)


void JDBCTransaction.begin()


void JDBCTransaction.commit()


void JDBCTransaction.rollback()

Constructors in net.sf.hibernate.transaction that throw HibernateException

JDBCTransaction(SessionImplementor session)

Uses of HibernateException in net.sf.hibernate.type

Subclasses of HibernateException in net.sf.hibernate.type

class SerializationException
Thrown when a property cannot be serializaed/deserialized

Methods in net.sf.hibernate.type that throw HibernateException

static void TypeFactory.deepCopy(Object[] values, Type[] types, boolean[] copy, Object[] target)
          Deep copy values in the first array into the second

static int[] TypeFactory.findDirty(Type[] types, Object[] x, Object[] y, boolean[] check, 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(Type[] types, Object[] old, Object[] current, boolean[] check, 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.

static Object[] TypeFactory.assemble(Serializable[] row, Type[] types, SessionImplementor session, Object owner)


static Serializable[] TypeFactory.disassemble(Object[] row, Type[] types, SessionImplementor session)


static Object[] TypeFactory.copy(Object[] original, Object[] target, Type[] types, SessionImplementor session, Object owner, Map copiedAlready)


boolean Type.equals(Object x, Object y)
          Compare two instances of the class mapped by this type for persistence "equality", ie.

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, SessionImplementor session)
          Write an instance of the mapped class to a prepared statement.

String Type.toString(Object value, SessionFactoryImplementor factory)
          A representation of the value to be embedded in an XML element.

Object Type.fromString(String xml)
          Parse the XML representation of an instance.

Object Type.deepCopy(Object value)
          Return a deep copy of the persistent state, stopping at entities and at collections.

Serializable Type.disassemble(Object value, SessionImplementor session)
          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.resolveIdentifier(Object value, SessionImplementor session, Object owner)
          Map identifiers to entities or collections.

Object Type.copy(Object original, Object target, SessionImplementor session, Object owner, Map copiedAlready)


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)


boolean TimeZoneType.equals(Object x, Object y)


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)


void SerializableType.set(PreparedStatement st, Object value, int index)


Object SerializableType.get(ResultSet rs, String name)


boolean SerializableType.equals(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 PersistentEnumType.get(ResultSet rs, String name)
          Deprecated.

Object PersistentEnumType.getInstance(Integer code)
          Deprecated.

Object PersistentEnumType.fromStringValue(String xml)
          Deprecated.

Object PersistentEnumType.assemble(Serializable cached, SessionImplementor session, Object owner)
          Deprecated.

Serializable PersistentEnumType.disassemble(Object value, SessionImplementor session)
          Deprecated.

abstract PersistentCollection PersistentCollectionType.instantiate(SessionImplementor session, CollectionPersister persister)


Object PersistentCollectionType.nullSafeGet(ResultSet rs, String name, SessionImplementor session, Object owner)


Object PersistentCollectionType.nullSafeGet(ResultSet rs, String[] name, SessionImplementor session, Object owner)


void PersistentCollectionType.nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)


String PersistentCollectionType.toString(Object value, SessionFactoryImplementor factory)


Object PersistentCollectionType.deepCopy(Object value)


Serializable PersistentCollectionType.disassemble(Object value, SessionImplementor session)


Object PersistentCollectionType.assemble(Serializable cached, SessionImplementor session, Object owner)


boolean PersistentCollectionType.isDirty(Object old, Object current, SessionImplementor session)


Object PersistentCollectionType.hydrate(ResultSet rs, String[] name, SessionImplementor session, Object owner)


Object PersistentCollectionType.resolveIdentifier(Object value, SessionImplementor session, Object owner)


boolean PersistentCollectionType.isModified(Object old, Object current, SessionImplementor session)


Object PersistentCollectionType.copy(Object original, Object target, SessionImplementor session, Object owner, Map copiedAlready)


void OneToOneType.nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)


boolean OneToOneType.isDirty(Object old, Object current, SessionImplementor session)


boolean OneToOneType.isModified(Object old, Object current, SessionImplementor session)


Object OneToOneType.hydrate(ResultSet rs, String[] names, SessionImplementor session, Object owner)


protected Object OneToOneType.resolveIdentifier(Serializable id, SessionImplementor session)


Serializable OneToOneType.disassemble(Object value, SessionImplementor session)


Object OneToOneType.assemble(Serializable oid, SessionImplementor session, Object owner)


Object ObjectType.deepCopy(Object value)


boolean ObjectType.equals(Object x, Object y)


Object ObjectType.nullSafeGet(ResultSet rs, String name, SessionImplementor session, Object owner)


Object ObjectType.nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)


Object ObjectType.hydrate(ResultSet rs, String[] names, SessionImplementor session, Object owner)


Object ObjectType.resolveIdentifier(Object value, SessionImplementor session, Object owner)


void ObjectType.nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)


String ObjectType.toString(Object value, SessionFactoryImplementor factory)


Object ObjectType.fromString(String xml)


Object ObjectType.assemble(Serializable cached, SessionImplementor session, Object owner)


Serializable ObjectType.disassemble(Object value, SessionImplementor session)


Object ObjectType.getPropertyValue(Object component, int i, SessionImplementor session)


Object[] ObjectType.getPropertyValues(Object component, SessionImplementor session)


void ObjectType.setPropertyValues(Object component, Object[] values)


boolean ObjectType.isModified(Object old, Object current, SessionImplementor session)


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, 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.toString(Object value, SessionFactoryImplementor pc)


Object NullableType.fromString(String xml)


abstract Object NullableType.deepCopyNotNull(Object value)


Object NullableType.deepCopy(Object value)


Object MutableType.copy(Object original, Object target, SessionImplementor session, Object owner, Map copiedAlready)


boolean MetaType.equals(Object x, Object y)


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)


String MetaType.toString(Object value, SessionFactoryImplementor factory)


Object MetaType.fromString(String xml)


Object MetaType.deepCopy(Object value)


Object MapType.copy(Object original, Object target, SessionImplementor session, Object owner, Map copiedAlready)


void ManyToOneType.nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)


Object ManyToOneType.hydrate(ResultSet rs, String[] names, SessionImplementor session, Object owner)


protected Object ManyToOneType.resolveIdentifier(Serializable id, SessionImplementor session)


boolean ManyToOneType.isModified(Object old, Object current, SessionImplementor session)


Serializable ManyToOneType.disassemble(Object value, SessionImplementor session)


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)


boolean LocaleType.equals(Object x, Object y)


Object ImmutableType.deepCopyNotNull(Object value)


Object ImmutableType.copy(Object original, Object target, SessionImplementor session, Object owner, Map copiedAlready)


PersistentCollection IdentifierBagType.instantiate(SessionImplementor session, CollectionPersister persister)


Object EntityType.nullSafeGet(ResultSet rs, String name, SessionImplementor session, Object owner)


protected Object EntityType.getIdentifier(Object value, SessionImplementor session)


String EntityType.toString(Object value, SessionFactoryImplementor factory)


Object EntityType.fromString(String xml)


Object EntityType.copy(Object original, Object target, SessionImplementor session, Object owner, Map copiedAlready)


Object EntityType.nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)


abstract Object EntityType.hydrate(ResultSet rs, String[] names, SessionImplementor session, Object owner)


boolean EntityType.isDirty(Object old, Object current, SessionImplementor session)


protected abstract Object EntityType.resolveIdentifier(Serializable id, SessionImplementor session)
          Resolve an identifier

Object EntityType.resolveIdentifier(Object value, SessionImplementor session, Object owner)
          Resolve an identifier or unique key value

Object DynamicComponentType.getPropertyValue(Object component, int i, SessionImplementor session)


Object[] DynamicComponentType.getPropertyValues(Object component, SessionImplementor session)


Object DynamicComponentType.getPropertyValue(Object component, int i)


Object[] DynamicComponentType.getPropertyValues(Object component)


Object DynamicComponentType.instantiate()


void DynamicComponentType.setPropertyValues(Object component, Object[] values)


Object DynamicComponentType.deepCopy(Object component)


Object DynamicComponentType.copy(Object original, Object target, SessionImplementor session, Object owner, Map copiedAlready)


boolean DynamicComponentType.equals(Object x, Object y)


boolean DynamicComponentType.isDirty(Object x, Object y, SessionImplementor session)


Object DynamicComponentType.nullSafeGet(ResultSet rs, String name, SessionImplementor session, Object owner)


Object DynamicComponentType.nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)


void DynamicComponentType.nullSafeSet(PreparedStatement st, Object value, int begin, SessionImplementor session)


String DynamicComponentType.toString(Object value, SessionFactoryImplementor factory)


Object DynamicComponentType.fromString(String xml)


Object DateType.fromStringValue(String xml)


boolean CustomType.equals(Object x, Object y)


Object CustomType.nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)


Object CustomType.nullSafeGet(ResultSet rs, String columnName, SessionImplementor session, Object owner)


void CustomType.nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)


Object CustomType.deepCopy(Object value)


Object CurrencyType.get(ResultSet rs, String name)


void CurrencyType.set(PreparedStatement st, Object value, int index)


String CurrencyType.toString(Object value)


boolean CurrencyType.equals(Object x, Object y)


Object CurrencyType.fromStringValue(String xml)


Object[] CompositeCustomType.getPropertyValues(Object component, SessionImplementor session)


Object[] CompositeCustomType.getPropertyValues(Object component)


void CompositeCustomType.setPropertyValues(Object component, Object[] values)


Object CompositeCustomType.getPropertyValue(Object component, int i, SessionImplementor session)


Object CompositeCustomType.getPropertyValue(Object component, int i)


Object CompositeCustomType.assemble(Serializable cached, SessionImplementor session, Object owner)


Object CompositeCustomType.deepCopy(Object value)


Serializable CompositeCustomType.disassemble(Object value, SessionImplementor session)


boolean CompositeCustomType.equals(Object x, Object y)


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)


String CompositeCustomType.toString(Object value, SessionFactoryImplementor factory)


boolean ComponentType.equals(Object x, Object y)


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)


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)


void ComponentType.setPropertyValues(Object component, Object[] values)


String ComponentType.toString(Object value, SessionFactoryImplementor factory)


Object ComponentType.fromString(String xml)


Object ComponentType.deepCopy(Object component)


Object ComponentType.copy(Object original, Object target, SessionImplementor session, Object owner, Map copiedAlready)


Object ComponentType.instantiate(Object parent, SessionImplementor session)


Serializable ComponentType.disassemble(Object value, SessionImplementor session)


Object ComponentType.assemble(Serializable object, SessionImplementor session, Object owner)


Object ComponentType.hydrate(ResultSet rs, String[] names, SessionImplementor session, Object owner)


Object ComponentType.resolveIdentifier(Object value, SessionImplementor session, Object owner)


boolean ComponentType.isModified(Object old, Object current, SessionImplementor session)


void ClobType.set(PreparedStatement st, Object value, int index)


Object ClobType.get(ResultSet rs, String name)


boolean ClobType.equals(Object x, Object y)


String ClobType.toString(Object val)


Serializable ClobType.disassemble(Object value, SessionImplementor session)


Object ClassType.get(ResultSet rs, String name)


void ClassType.set(PreparedStatement st, Object value, int index)


String ClassType.toString(Object value)


boolean ClassType.equals(Object x, Object y)


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)


boolean CalendarType.equals(Object x, Object y)


Object CalendarDateType.get(ResultSet rs, String name)


void CalendarDateType.set(PreparedStatement st, Object value, int index)


String CalendarDateType.toString(Object value)


Object CalendarDateType.fromStringValue(String xml)


Object CalendarDateType.deepCopyNotNull(Object value)


boolean CalendarDateType.equals(Object x, Object y)


void BlobType.set(PreparedStatement st, Object value, int index)


Object BlobType.get(ResultSet rs, String name)


boolean BlobType.equals(Object x, Object y)


String BlobType.toString(Object val)


Serializable BlobType.disassemble(Object value, SessionImplementor session)


void BinaryType.set(PreparedStatement st, Object value, int index)


Object BinaryType.get(ResultSet rs, String name)


Object BinaryType.fromStringValue(String xml)


Object BigDecimalType.get(ResultSet rs, String name)


void BigDecimalType.set(PreparedStatement st, Object value, int index)


String BigDecimalType.toString(Object value)


boolean BigDecimalType.equals(Object x, Object y)


PersistentCollection BagType.instantiate(SessionImplementor session, CollectionPersister persister)


PersistentCollection ArrayType.instantiate(SessionImplementor session, CollectionPersister persister)


void ArrayType.nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)


Serializable ArrayType.disassemble(Object value, SessionImplementor session)


String ArrayType.toString(Object value, SessionFactoryImplementor factory)


Object ArrayType.copy(Object original, Object target, SessionImplementor session, Object owner, Map copiedAlready)


Serializable AbstractType.disassemble(Object value, SessionImplementor session)


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.resolveIdentifier(Object value, SessionImplementor session, Object owner)


boolean AbstractType.isModified(Object old, Object current, SessionImplementor session)


Object AbstractType.copy(Object original, Object target, SessionImplementor session, Object owner, Map copiedAlready)


Object[] AbstractComponentType.getPropertyValues(Object component, SessionImplementor session)


Object[] AbstractComponentType.getPropertyValues(Object component)
          Optional operation

void AbstractComponentType.setPropertyValues(Object component, Object[] values)
          Optional operation

Object AbstractComponentType.getPropertyValue(Object component, int i, SessionImplementor session)

Uses of HibernateException in net.sf.hibernate.util

Methods in net.sf.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.

Uses of HibernateException in net.sf.hibernate.xml

Methods in net.sf.hibernate.xml that throw HibernateException

String XMLDatabinder.toGenericXML()


String XMLDatabinder.toXML()


org.w3c.dom.Document XMLDatabinder.toDOM()


org.w3c.dom.Document XMLDatabinder.toGenericDOM()