|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
| Uses of HibernateException in org.hibernate |
|---|
| Subclasses of HibernateException in org.hibernate | |
|---|---|
class |
AnnotationException
Annotation related exception. |
class |
CallbackException
Should be thrown by persistent objects from Lifecycle or Interceptor callbacks. |
class |
DuplicateMappingException
Raised whenever a duplicate for a certain type occurs. |
class |
InstantiationException
Thrown if Hibernate can't instantiate an entity or component class at runtime. |
class |
InvalidMappingException
Thrown when a mapping is found to be invalid. |
class |
JDBCException
Wraps an SQLException. |
class |
LazyInitializationException
Indicates access to unfetched data outside of a session context. |
class |
MappingException
An exception that usually occurs at configuration time, rather than runtime, as a result of something screwy in the O-R mappings. |
class |
MappingNotFoundException
Thrown when a resource for a mapping could not be found. |
class |
NonUniqueObjectException
This exception is thrown when an operation would break session-scoped identity. |
class |
NonUniqueResultException
Thrown when the application calls Query.uniqueResult() and the query returned more than one result. |
class |
ObjectDeletedException
Thrown when the user tries to do something illegal with a deleted object. |
class |
ObjectNotFoundException
Thrown when Session.load() fails to select a row with the given primary key (identifier value). |
class |
OptimisticLockException
Deprecated. Use OptimisticEntityLockException instead |
class |
PersistentObjectException
Thrown when the user passes a persistent instance to a Session method that expects a transient instance. |
class |
PessimisticLockException
Thrown when a pessimistic locking conflict occurs. |
class |
PropertyAccessException
A problem occurred accessing a property of an instance of a persistent class by reflection, or via CGLIB. |
class |
PropertyNotFoundException
Indicates that an expected getter or setter method could not be found on a class. |
class |
PropertyValueException
Thrown when the (illegal) value of a property can not be persisted. |
class |
QueryException
A problem occurred translating a Hibernate query to SQL due to invalid query syntax, etc. |
class |
QueryParameterException
Parameter invalid or not found in the query |
class |
QueryTimeoutException
Thrown when a database query timeout occurs. |
class |
ResourceClosedException
Indicates an attempt was made to use a closed resource (Session, SessionFactory, etc). |
class |
SessionException
Thrown when the user calls a method of a Session that is in an inappropriate state for the given call (for
example, the the session is closed or disconnected). |
class |
StaleObjectStateException
A StaleStateException that carries information about a particular entity instance that was the source of the failure. |
class |
StaleStateException
Thrown when a version number or timestamp check failed, indicating that the Session contained stale data (when using long transactions with versioning). |
class |
TransactionException
Indicates that a transaction could not be begun, committed or rolled back. |
class |
TransientObjectException
Thrown when the user passes a transient instance to a Session method that expects a persistent instance. |
class |
TransientPropertyValueException
Thrown when a property cannot be persisted because it is an association with a transient unsaved entity instance. |
class |
TypeMismatchException
Used when a user provided type does not match the expected one |
class |
UnknownProfileException
Used to indicate a request against an unknown profile name. |
class |
UnresolvableObjectException
Thrown when Hibernate could not resolve an object by id, especially when loading an association. |
class |
WrongClassException
Thrown when Session.load() selects a row with the given primary key (identifier value) but the row's discriminator value specifies a subclass that is not assignable to the class requested by the user. |
| Methods in org.hibernate that throw HibernateException | ||
|---|---|---|
void |
ScrollableResults.afterLast()
Go to a location just after the last result |
|
void |
ScrollableResults.beforeFirst()
Go to a location just before first result (this is the initial location) |
|
void |
Session.cancelQuery()
Cancel the execution of the current query. |
|
void |
ScrollableResults.close()
Release resources immediately. |
|
Connection |
Session.close()
End the session by releasing the JDBC connection and cleaning up. |
|
void |
SessionFactory.close()
Destroy this SessionFactory and release all resources (caches, connection pools, etc). |
|
static void |
Hibernate.close(Iterator iterator)
Close an Iterator created by iterate() immediately, instead of waiting until the session is closed or disconnected. |
|
Criteria |
Criteria.createAlias(String associationPath,
String alias)
Join an association, assigning an alias to the joined association. |
|
Criteria |
Criteria.createAlias(String associationPath,
String alias,
int joinType)
Deprecated. use Criteria.createAlias(String, String, org.hibernate.sql.JoinType) |
|
Criteria |
Criteria.createAlias(String associationPath,
String alias,
int joinType,
Criterion withClause)
Deprecated. use Criteria.createAlias(String, String, JoinType, Criterion) |
|
Criteria |
Criteria.createAlias(String associationPath,
String alias,
JoinType joinType)
Join an association using the specified join-type, assigning an alias to the joined association. |
|
Criteria |
Criteria.createAlias(String associationPath,
String alias,
JoinType joinType,
Criterion withClause)
Join an association using the specified join-type, assigning an alias to the joined association. |
|
Criteria |
Criteria.createCriteria(String associationPath)
Create a new Criteria, "rooted" at the associated entity. |
|
Criteria |
Criteria.createCriteria(String associationPath,
int joinType)
Deprecated. use Criteria.createAlias(String, String, org.hibernate.sql.JoinType) |
|
Criteria |
Criteria.createCriteria(String associationPath,
JoinType joinType)
Create a new Criteria, "rooted" at the associated entity, using the specified join type. |
|
Criteria |
Criteria.createCriteria(String associationPath,
String alias)
Create a new Criteria, "rooted" at the associated entity, assigning the given alias. |
|
Criteria |
Criteria.createCriteria(String associationPath,
String alias,
int joinType)
Deprecated. use Criteria.createCriteria(String, org.hibernate.sql.JoinType) |
|
Criteria |
Criteria.createCriteria(String associationPath,
String alias,
int joinType,
Criterion withClause)
Deprecated. use Criteria.createCriteria(String, String, org.hibernate.sql.JoinType, org.hibernate.criterion.Criterion) |
|
Criteria |
Criteria.createCriteria(String associationPath,
String alias,
JoinType joinType)
Create a new Criteria, "rooted" at the associated entity, assigning the given alias and using the specified join type. |
|
Criteria |
Criteria.createCriteria(String associationPath,
String alias,
JoinType joinType,
Criterion withClause)
Create a new Criteria, "rooted" at the associated entity, assigning the given alias and using the specified join type. |
|
|
Session.doReturningWork(ReturningWork<T> work)
Controller for allowing users to perform JDBC related work using the Connection managed by this Session. |
|
void |
Session.doWork(Work work)
Controller for allowing users to perform JDBC related work using the Connection managed by this Session. |
|
void |
SessionFactory.evict(Class persistentClass)
Deprecated. Use Cache.evictEntityRegion(Class) accessed through
SessionFactory.getCache() instead. |
|
void |
SessionFactory.evict(Class persistentClass,
Serializable id)
Deprecated. Use Cache.containsEntity(Class, Serializable) accessed through
SessionFactory.getCache() instead. |
|
void |
SessionFactory.evictCollection(String roleName)
Deprecated. Use Cache.evictCollectionRegion(String) accessed through
SessionFactory.getCache() instead. |
|
void |
SessionFactory.evictCollection(String roleName,
Serializable id)
Deprecated. Use Cache.evictCollection(String,Serializable) accessed through
SessionFactory.getCache() instead. |
|
void |
SessionFactory.evictEntity(String entityName)
Deprecated. Use Cache.evictEntityRegion(String) accessed through
SessionFactory.getCache() instead. |
|
void |
SessionFactory.evictEntity(String entityName,
Serializable id)
Deprecated. Use Cache.evictEntity(String,Serializable) accessed through
SessionFactory.getCache() instead. |
|
void |
SessionFactory.evictQueries()
Deprecated. Use Cache.evictQueryRegions() accessed through
SessionFactory.getCache() instead. |
|
void |
SessionFactory.evictQueries(String cacheRegion)
Deprecated. Use Cache.evictQueryRegion(String) accessed through
SessionFactory.getCache() instead. |
|
int |
Query.executeUpdate()
Execute the update or delete statement. |
|
boolean |
ScrollableResults.first()
Go to the first result |
|
void |
Session.flush()
Force this session to flush. |
|
Object[] |
ScrollableResults.get()
Get the current row of results |
|
Object |
ScrollableResults.get(int i)
Get the ith object in the current row of results, without initializing any other results in the row. |
|
BigDecimal |
ScrollableResults.getBigDecimal(int col)
Convenience method to read a big_decimal |
|
BigInteger |
ScrollableResults.getBigInteger(int col)
Convenience method to read a big_integer |
|
byte[] |
ScrollableResults.getBinary(int col)
Convenience method to read a binary |
|
Blob |
ScrollableResults.getBlob(int col)
Convenience method to read a blob |
|
Boolean |
ScrollableResults.getBoolean(int col)
Convenience method to read a boolean |
|
Byte |
ScrollableResults.getByte(int col)
Convenience method to read a byte |
|
Calendar |
ScrollableResults.getCalendar(int col)
Convenience method to read a calendar or calendar_date |
|
Character |
ScrollableResults.getCharacter(int col)
Convenience method to read a character |
|
Clob |
ScrollableResults.getClob(int col)
Convenience method to read a clob |
|
Session |
SessionFactory.getCurrentSession()
Obtains the current session. |
|
Date |
ScrollableResults.getDate(int col)
Convenience method to read a date, time or timestamp |
|
Double |
ScrollableResults.getDouble(int col)
Convenience method to read a double |
|
FilterDefinition |
SessionFactory.getFilterDefinition(String filterName)
Obtain the definition of a filter by name. |
|
Float |
ScrollableResults.getFloat(int col)
Convenience method to read a float |
|
Integer |
ScrollableResults.getInteger(int col)
Convenience method to read an integer |
|
Locale |
ScrollableResults.getLocale(int col)
Convenience method to read a locale |
|
Long |
ScrollableResults.getLong(int col)
Convenience method to read a long |
|
String[] |
Query.getNamedParameters()
Return the names of all named parameters of the query. |
|
String[] |
Query.getReturnAliases()
Return the HQL select clause aliases (if any) |
|
Type[] |
Query.getReturnTypes()
Return the Hibernate types of the query result set. |
|
int |
ScrollableResults.getRowNumber()
Get the current location in the result set. |
|
Short |
ScrollableResults.getShort(int col)
Convenience method to read a short |
|
String |
ScrollableResults.getString(int col)
Convenience method to read a string |
|
String |
ScrollableResults.getText(int col)
Convenience method to read text |
|
TimeZone |
ScrollableResults.getTimeZone(int col)
Convenience method to read a timezone |
|
static void |
Hibernate.initialize(Object proxy)
Force initialization of a proxy or persistent collection. |
|
boolean |
Session.isDirty()
Does this session contain any changes which must be synchronized with the database? In other words, would any DML operations be executed if we flushed this session? |
|
boolean |
ScrollableResults.isFirst()
Is this the first result? |
|
boolean |
ScrollableResults.isLast()
Is this the last result? |
|
Iterator |
Query.iterate()
Return the query results as an Iterator. |
|
boolean |
ScrollableResults.last()
Go to the last result |
|
List |
Criteria.list()
Get the results. |
|
List |
Query.list()
Return the query results as a List. |
|
void |
Session.LockRequest.lock(Object object)
|
|
void |
Session.LockRequest.lock(String entityName,
Object object)
|
|
boolean |
ScrollableResults.next()
Advance to the next result |
|
Session |
SessionFactory.openSession()
Open a Session. |
|
boolean |
ScrollableResults.previous()
Retreat to the previous result |
|
void |
Transaction.registerSynchronization(Synchronization synchronization)
Register a user synchronization callback for this transaction. |
|
ScrollableResults |
Criteria.scroll()
Get the results as an instance of ScrollableResults |
|
ScrollableResults |
Query.scroll()
Return the query results as ScrollableResults. |
|
boolean |
ScrollableResults.scroll(int i)
Scroll an arbitrary number of locations |
|
ScrollableResults |
Criteria.scroll(ScrollMode scrollMode)
Get the results as an instance of ScrollableResults based on the
given scroll mode. |
|
ScrollableResults |
Query.scroll(ScrollMode scrollMode)
Return the query results as ScrollableResults. |
|
Criteria |
Criteria.setFetchMode(String associationPath,
FetchMode mode)
Specify an association fetching strategy for an association or a collection of values. |
|
Query |
Query.setParameter(int position,
Object val)
Bind a value to a JDBC-style query parameter. |
|
Query |
Query.setParameter(String name,
Object val)
Bind a value to a named query parameter. |
|
Query |
Query.setParameterList(String name,
Collection vals)
Bind multiple values to a named query parameter. |
|
Query |
Query.setParameterList(String name,
Collection vals,
Type type)
Bind multiple values to a named query parameter. |
|
Query |
Query.setParameterList(String name,
Object[] vals)
Bind multiple values to a named query parameter. |
|
Query |
Query.setParameterList(String name,
Object[] vals,
Type type)
Bind multiple values to a named query parameter. |
|
Query |
Query.setParameters(Object[] values,
Type[] types)
Bind values and types to positional parameters. |
|
Query |
Query.setProperties(Map bean)
Bind the values of the given Map for each named parameters of the query, matching key names with parameter names and mapping value types to Hibernate types using hueristics. |
|
Query |
Query.setProperties(Object bean)
Bind the property values of the given bean to named parameters of the query, matching property names with parameter names and mapping property types to Hibernate types using hueristics. |
|
boolean |
ScrollableResults.setRowNumber(int rowNumber)
Set the current location in the result set, numbered from either the first row (row number 0), or the last row (row number -1). |
|
Object |
Criteria.uniqueResult()
Convenience method to return a single instance that matches the query, or null if the query returns no results. |
|
Object |
Query.uniqueResult()
Convenience method to return a single instance that matches the query, or null if the query returns no results. |
|
void |
Filter.validate()
Perform validation of the filter state. |
|
| Uses of HibernateException in org.hibernate.action.internal |
|---|
| Methods in org.hibernate.action.internal that throw HibernateException | |
|---|---|
void |
BulkOperationCleanupAction.beforeExecutions()
|
void |
EntityInsertAction.doAfterTransactionCompletion(boolean success,
SessionImplementor session)
|
void |
EntityDeleteAction.doAfterTransactionCompletion(boolean success,
SessionImplementor session)
|
void |
EntityInsertAction.execute()
|
void |
BulkOperationCleanupAction.execute()
|
void |
EntityIdentityInsertAction.execute()
|
void |
EntityDeleteAction.execute()
|
void |
CollectionRecreateAction.execute()
|
void |
EntityUpdateAction.execute()
|
void |
CollectionUpdateAction.execute()
|
void |
CollectionRemoveAction.execute()
|
| Constructors in org.hibernate.action.internal that throw HibernateException | |
|---|---|
EntityIdentityInsertAction(Object[] state,
Object instance,
EntityPersister persister,
boolean isVersionIncrementDisabled,
SessionImplementor session,
boolean isDelayed)
|
|
EntityInsertAction(Serializable id,
Object[] state,
Object instance,
Object version,
EntityPersister persister,
boolean isVersionIncrementDisabled,
SessionImplementor session)
|
|
EntityUpdateAction(Serializable id,
Object[] state,
int[] dirtyProperties,
boolean hasDirtyCollection,
Object[] previousState,
Object previousVersion,
Object nextVersion,
Object instance,
Object rowId,
EntityPersister persister,
SessionImplementor session)
|
|
| Uses of HibernateException in org.hibernate.action.spi |
|---|
| Methods in org.hibernate.action.spi that throw HibernateException | |
|---|---|
void |
Executable.beforeExecutions()
Called before executing any actions. |
void |
Executable.execute()
Execute this action |
| Uses of HibernateException in org.hibernate.bytecode.spi |
|---|
| Subclasses of HibernateException in org.hibernate.bytecode.spi | |
|---|---|
class |
NotInstrumentedException
|
| Uses of HibernateException in org.hibernate.cache |
|---|
| Subclasses of HibernateException in org.hibernate.cache | |
|---|---|
class |
CacheException
Something went wrong in the cache |
class |
NoCacheRegionFactoryAvailableException
Implementation of NoCacheRegionFactoryAvailableException. |
| Uses of HibernateException in org.hibernate.cache.ehcache |
|---|
| Methods in org.hibernate.cache.ehcache with parameters of type HibernateException | |
|---|---|
void |
EhCacheMessageLogger_$logger.namedQueryError(String arg0,
HibernateException arg1)
|
void |
EhCacheMessageLogger_$logger.unableToCloseSession(HibernateException arg0)
|
void |
EhCacheMessageLogger_$logger.unableToCloseSessionButSwallowingError(HibernateException arg0)
|
void |
EhCacheMessageLogger_$logger.unableToConfigureSqlExceptionConverter(HibernateException arg0)
|
void |
EhCacheMessageLogger_$logger.unableToCreateProxyFactory(String arg0,
HibernateException arg1)
|
void |
EhCacheMessageLogger_$logger.unableToLoadCommand(HibernateException arg0)
|
void |
EhCacheMessageLogger_$logger.unableToSynchronizeDatabaseStateWithSession(HibernateException arg0)
|
| Uses of HibernateException in org.hibernate.cache.internal |
|---|
| Methods in org.hibernate.cache.internal that throw HibernateException | |
|---|---|
List |
StandardQueryCache.get(QueryKey key,
Type[] returnTypes,
boolean isNaturalKeyLookup,
Set spaces,
SessionImplementor session)
|
QueryCache |
StandardQueryCacheFactory.getQueryCache(String regionName,
UpdateTimestampsCache updateTimestampsCache,
Settings settings,
Properties props)
|
boolean |
StandardQueryCache.put(QueryKey key,
Type[] returnTypes,
List result,
boolean isNaturalKeyLookup,
SessionImplementor session)
|
| Constructors in org.hibernate.cache.internal that throw HibernateException | |
|---|---|
StandardQueryCache(Settings settings,
Properties props,
UpdateTimestampsCache updateTimestampsCache,
String regionName)
|
|
| Uses of HibernateException in org.hibernate.cache.spi |
|---|
| Methods in org.hibernate.cache.spi that throw HibernateException | |
|---|---|
List |
QueryCache.get(QueryKey key,
Type[] returnTypes,
boolean isNaturalKeyLookup,
Set spaces,
SessionImplementor session)
|
QueryCache |
QueryCacheFactory.getQueryCache(String regionName,
UpdateTimestampsCache updateTimestampsCache,
Settings settings,
Properties props)
|
boolean |
UpdateTimestampsCache.isUpToDate(Set spaces,
Long timestamp)
|
boolean |
QueryCache.put(QueryKey key,
Type[] returnTypes,
List result,
boolean isNaturalKeyLookup,
SessionImplementor session)
|
| Constructors in org.hibernate.cache.spi that throw HibernateException | |
|---|---|
UpdateTimestampsCache(Settings settings,
Properties props)
|
|
UpdateTimestampsCache(Settings settings,
Properties props,
SessionFactoryImplementor factory)
|
|
| Uses of HibernateException in org.hibernate.cache.spi.access |
|---|
| Subclasses of HibernateException in org.hibernate.cache.spi.access | |
|---|---|
class |
UnknownAccessTypeException
|
| Uses of HibernateException in org.hibernate.cache.spi.entry |
|---|
| Methods in org.hibernate.cache.spi.entry that throw HibernateException | |
|---|---|
Object[] |
CacheEntry.assemble(Object instance,
Serializable id,
EntityPersister persister,
Interceptor interceptor,
EventSource session)
|
| Constructors in org.hibernate.cache.spi.entry that throw HibernateException | |
|---|---|
CacheEntry(Object[] state,
EntityPersister persister,
boolean unfetched,
Object version,
SessionImplementor session,
Object owner)
|
|
| Uses of HibernateException in org.hibernate.cfg |
|---|
| Subclasses of HibernateException in org.hibernate.cfg | |
|---|---|
class |
NotYetImplementedException
Mapping not yet implemented |
class |
RecoverableException
Should neven be exposed to the client An exception that wrap an underlying exception whith the hope subsequent processing will recover from it. |
| Methods in org.hibernate.cfg that throw HibernateException | |
|---|---|
SessionFactory |
Configuration.buildSessionFactory()
Deprecated. Use Configuration.buildSessionFactory(ServiceRegistry) instead |
SessionFactory |
Configuration.buildSessionFactory(ServiceRegistry serviceRegistry)
Create a SessionFactory using the properties and mappings in this configuration. |
Settings |
Configuration.buildSettings(Properties props,
ServiceRegistry serviceRegistry)
|
Configuration |
Configuration.configure()
Use the mappings and properties specified in an application resource named hibernate.cfg.xml. |
AnnotationConfiguration |
AnnotationConfiguration.configure()
Deprecated. |
Configuration |
Configuration.configure(Document document)
Use the mappings and properties specified in the given XML document. |
AnnotationConfiguration |
AnnotationConfiguration.configure(Document document)
Deprecated. |
Configuration |
Configuration.configure(File configFile)
Use the mappings and properties specified in the given application file. |
AnnotationConfiguration |
AnnotationConfiguration.configure(File configFile)
Deprecated. |
Configuration |
Configuration.configure(String resource)
Use the mappings and properties specified in the given application resource. |
AnnotationConfiguration |
AnnotationConfiguration.configure(String resource)
Deprecated. |
Configuration |
Configuration.configure(URL url)
Use the mappings and properties specified in the given document. |
AnnotationConfiguration |
AnnotationConfiguration.configure(URL url)
Deprecated. |
protected Configuration |
Configuration.doConfigure(org.dom4j.Document doc)
Parse a dom4j document conforming to the Hibernate Configuration DTD (hibernate-configuration-3.0.dtd) and use its information to configure this Configuration's state |
protected AnnotationConfiguration |
AnnotationConfiguration.doConfigure(org.dom4j.Document doc)
Deprecated. |
protected Configuration |
Configuration.doConfigure(InputStream stream,
String resourceName)
Configure this configuration's state from the contents of the given input stream. |
protected AnnotationConfiguration |
AnnotationConfiguration.doConfigure(InputStream stream,
String resourceName)
Deprecated. |
String[] |
Configuration.generateDropSchemaScript(Dialect dialect)
Generate DDL for dropping tables |
String[] |
Configuration.generateSchemaCreationScript(Dialect dialect)
|
String[] |
Configuration.generateSchemaUpdateScript(Dialect dialect,
DatabaseMetadata databaseMetadata)
|
protected InputStream |
Configuration.getConfigurationInputStream(String resource)
Get the configuration file as an InputStream. |
void |
Configuration.validateSchema(Dialect dialect,
DatabaseMetadata databaseMetadata)
|
| Uses of HibernateException in org.hibernate.collection.internal |
|---|
| Methods in org.hibernate.collection.internal that throw HibernateException | |
|---|---|
void |
AbstractPersistentCollection.afterRowInsert(CollectionPersister persister,
Object entry,
int i)
Called after inserting a row, to fetch the natively generated id |
void |
PersistentIdentifierBag.afterRowInsert(CollectionPersister persister,
Object entry,
int i)
|
Serializable |
PersistentMap.disassemble(CollectionPersister persister)
|
Serializable |
PersistentMapElementHolder.disassemble(CollectionPersister persister)
|
Serializable |
PersistentBag.disassemble(CollectionPersister persister)
|
Serializable |
PersistentList.disassemble(CollectionPersister persister)
|
Serializable |
PersistentElementHolder.disassemble(CollectionPersister persister)
|
Serializable |
PersistentListElementHolder.disassemble(CollectionPersister persister)
|
Serializable |
PersistentIdentifierBag.disassemble(CollectionPersister persister)
|
Serializable |
PersistentArrayHolder.disassemble(CollectionPersister persister)
|
Serializable |
PersistentSet.disassemble(CollectionPersister persister)
|
boolean |
PersistentMap.equalsSnapshot(CollectionPersister persister)
|
boolean |
PersistentIndexedElementHolder.equalsSnapshot(CollectionPersister persister)
|
boolean |
PersistentBag.equalsSnapshot(CollectionPersister persister)
|
boolean |
PersistentList.equalsSnapshot(CollectionPersister persister)
|
boolean |
PersistentElementHolder.equalsSnapshot(CollectionPersister persister)
|
boolean |
PersistentIdentifierBag.equalsSnapshot(CollectionPersister persister)
|
boolean |
PersistentArrayHolder.equalsSnapshot(CollectionPersister persister)
|
boolean |
PersistentSet.equalsSnapshot(CollectionPersister persister)
|
void |
AbstractPersistentCollection.forceInitialization()
To be called internally by the session, forcing immediate initialization. |
Iterator |
PersistentMap.getDeletes(CollectionPersister persister,
boolean indexIsFormula)
|
Iterator |
PersistentIndexedElementHolder.getDeletes(CollectionPersister persister,
boolean indexIsFormula)
|
Iterator |
PersistentBag.getDeletes(CollectionPersister persister,
boolean indexIsFormula)
|
Iterator |
PersistentList.getDeletes(CollectionPersister persister,
boolean indexIsFormula)
|
Iterator |
PersistentElementHolder.getDeletes(CollectionPersister persister,
boolean indexIsFormula)
|
Iterator |
PersistentIdentifierBag.getDeletes(CollectionPersister persister,
boolean indexIsFormula)
|
Iterator |
PersistentArrayHolder.getDeletes(CollectionPersister persister,
boolean indexIsFormula)
|
Iterator |
PersistentSet.getDeletes(CollectionPersister persister,
boolean indexIsFormula)
|
protected static Collection |
AbstractPersistentCollection.getOrphans(Collection oldElements,
Collection currentElements,
String entityName,
SessionImplementor session)
Given a collection of entity instances that used to belong to the collection, and a collection of instances that currently belong, return a collection of orphans |
Collection |
PersistentMap.getOrphans(Serializable snapshot,
String entityName)
|
Collection |
PersistentIndexedElementHolder.getOrphans(Serializable snapshot,
String entityName)
|
Collection |
PersistentBag.getOrphans(Serializable snapshot,
String entityName)
|
Collection |
PersistentList.getOrphans(Serializable snapshot,
String entityName)
|
Collection |
PersistentElementHolder.getOrphans(Serializable snapshot,
String entityName)
|
abstract Collection |
AbstractPersistentCollection.getOrphans(Serializable snapshot,
String entityName)
get all "orphaned" elements |
Collection |
PersistentIdentifierBag.getOrphans(Serializable snapshot,
String entityName)
|
Collection |
PersistentArrayHolder.getOrphans(Serializable snapshot,
String entityName)
|
Collection |
PersistentSet.getOrphans(Serializable snapshot,
String entityName)
|
Serializable |
PersistentMap.getSnapshot(CollectionPersister persister)
|
Serializable |
PersistentIndexedElementHolder.getSnapshot(CollectionPersister persister)
|
Serializable |
PersistentBag.getSnapshot(CollectionPersister persister)
|
Serializable |
PersistentList.getSnapshot(CollectionPersister persister)
|
Serializable |
PersistentElementHolder.getSnapshot(CollectionPersister persister)
|
Serializable |
PersistentIdentifierBag.getSnapshot(CollectionPersister persister)
|
Serializable |
PersistentArrayHolder.getSnapshot(CollectionPersister persister)
|
Serializable |
PersistentSet.getSnapshot(CollectionPersister persister)
|
static void |
AbstractPersistentCollection.identityRemove(Collection list,
Object object,
String entityName,
SessionImplementor session)
|
void |
PersistentMap.initializeFromCache(CollectionPersister persister,
Serializable disassembled,
Object owner)
|
void |
PersistentMapElementHolder.initializeFromCache(CollectionPersister persister,
Serializable disassembled,
Object owner)
|
void |
PersistentBag.initializeFromCache(CollectionPersister persister,
Serializable disassembled,
Object owner)
|
void |
PersistentList.initializeFromCache(CollectionPersister persister,
Serializable disassembled,
Object owner)
|
void |
PersistentElementHolder.initializeFromCache(CollectionPersister persister,
Serializable disassembled,
Object owner)
|
void |
PersistentListElementHolder.initializeFromCache(CollectionPersister persister,
Serializable disassembled,
Object owner)
|
void |
PersistentIdentifierBag.initializeFromCache(CollectionPersister persister,
Serializable disassembled,
Object owner)
|
void |
PersistentArrayHolder.initializeFromCache(CollectionPersister persister,
Serializable disassembled,
Object owner)
|
void |
PersistentSet.initializeFromCache(CollectionPersister persister,
Serializable disassembled,
Object owner)
|
boolean |
PersistentMap.needsInserting(Object entry,
int i,
Type elemType)
|
boolean |
PersistentIndexedElementHolder.needsInserting(Object entry,
int i,
Type elementType)
|
boolean |
PersistentBag.needsInserting(Object entry,
int i,
Type elemType)
|
boolean |
PersistentList.needsInserting(Object entry,
int i,
Type elemType)
|
boolean |
PersistentElementHolder.needsInserting(Object entry,
int i,
Type elementType)
|
boolean |
PersistentIdentifierBag.needsInserting(Object entry,
int i,
Type elemType)
|
boolean |
PersistentArrayHolder.needsInserting(Object entry,
int i,
Type elemType)
|
boolean |
PersistentSet.needsInserting(Object entry,
int i,
Type elemType)
|
boolean |
PersistentMap.needsUpdating(Object entry,
int i,
Type elemType)
|
boolean |
PersistentIndexedElementHolder.needsUpdating(Object entry,
int i,
Type elementType)
|
boolean |
PersistentList.needsUpdating(Object entry,
int i,
Type elemType)
|
boolean |
PersistentElementHolder.needsUpdating(Object entry,
int i,
Type elementType)
|
boolean |
PersistentIdentifierBag.needsUpdating(Object entry,
int i,
Type elemType)
|
boolean |
PersistentArrayHolder.needsUpdating(Object entry,
int i,
Type elemType)
|
void |
AbstractPersistentCollection.preInsert(CollectionPersister persister)
Called before inserting rows, to ensure that any surrogate keys are fully generated |
void |
PersistentIdentifierBag.preInsert(CollectionPersister persister)
|
Object |
PersistentMap.readFrom(ResultSet rs,
CollectionPersister persister,
CollectionAliases descriptor,
Object owner)
|
Object |
PersistentIndexedElementHolder.readFrom(ResultSet rs,
CollectionPersister persister,
CollectionAliases descriptor,
Object owner)
|
Object |
PersistentBag.readFrom(ResultSet rs,
CollectionPersister persister,
CollectionAliases descriptor,
Object owner)
|
Object |
PersistentList.readFrom(ResultSet rs,
CollectionPersister persister,
CollectionAliases descriptor,
Object owner)
|
Object |
PersistentElementHolder.readFrom(ResultSet rs,
CollectionPersister persister,
CollectionAliases descriptor,
Object owner)
|
Object |
PersistentIdentifierBag.readFrom(ResultSet rs,
CollectionPersister persister,
CollectionAliases descriptor,
Object owner)
|
Object |
PersistentArrayHolder.readFrom(ResultSet rs,
CollectionPersister persister,
CollectionAliases descriptor,
Object owner)
|
Object |
PersistentSet.readFrom(ResultSet rs,
CollectionPersister persister,
CollectionAliases descriptor,
Object owner)
|
boolean |
AbstractPersistentCollection.setCurrentSession(SessionImplementor session)
Associate the collection with the given session. |
protected Serializable |
PersistentSortedSet.snapshot(BasicCollectionPersister persister,
EntityMode entityMode)
|
protected Serializable |
PersistentSortedMap.snapshot(BasicCollectionPersister persister,
EntityMode entityMode)
|
| Constructors in org.hibernate.collection.internal that throw HibernateException | |
|---|---|
PersistentArrayHolder(SessionImplementor session,
CollectionPersister persister)
|
|
PersistentElementHolder(SessionImplementor session,
CollectionPersister persister,
Serializable key)
|
|
PersistentIndexedElementHolder(SessionImplementor session,
CollectionPersister persister,
Serializable key)
|
|
PersistentListElementHolder(SessionImplementor session,
CollectionPersister persister,
Serializable key)
|
|
PersistentMapElementHolder(SessionImplementor session,
CollectionPersister persister,
Serializable key)
|
|
| Uses of HibernateException in org.hibernate.collection.spi |
|---|
| Methods in org.hibernate.collection.spi that throw HibernateException | |
|---|---|
void |
PersistentCollection.afterRowInsert(CollectionPersister persister,
Object entry,
int i)
Called after inserting a row, to fetch the natively generated id |
Serializable |
PersistentCollection.disassemble(CollectionPersister persister)
Disassemble the collection, ready for the cache |
boolean |
PersistentCollection.equalsSnapshot(CollectionPersister persister)
Does the current state exactly match the snapshot? |
void |
PersistentCollection.forceInitialization()
To be called internally by the session, forcing immediate initialization. |
Iterator |
PersistentCollection.getDeletes(CollectionPersister persister,
boolean indexIsFormula)
Get all the elements that need deleting |
Collection |
PersistentCollection.getOrphans(Serializable snapshot,
String entityName)
get all "orphaned" elements |
Serializable |
PersistentCollection.getSnapshot(CollectionPersister persister)
Return a new snapshot of the current state of the collection |
void |
PersistentCollection.initializeFromCache(CollectionPersister persister,
Serializable disassembled,
Object owner)
Read the state of the collection from a disassembled cached value |
boolean |
PersistentCollection.needsInserting(Object entry,
int i,
Type elemType)
Do we need to insert this element? |
boolean |
PersistentCollection.needsUpdating(Object entry,
int i,
Type elemType)
Do we need to update this element? |
void |
PersistentCollection.preInsert(CollectionPersister persister)
Called before inserting rows, to ensure that any surrogate keys are fully generated |
Object |
PersistentCollection.readFrom(ResultSet rs,
CollectionPersister role,
CollectionAliases descriptor,
Object owner)
Read a row from the JDBC result set |
boolean |
PersistentCollection.setCurrentSession(SessionImplementor session)
Associate the collection with the given session. |
| Uses of HibernateException in org.hibernate.context |
|---|
| Subclasses of HibernateException in org.hibernate.context | |
|---|---|
class |
TenantIdentifierMismatchException
Indicates that tenant identifiers did not match in cases where CurrentTenantIdentifierResolver.validateExistingCurrentSessions() returns
true and there is a mismatch found. |
| Uses of HibernateException in org.hibernate.context.internal |
|---|
| Methods in org.hibernate.context.internal that throw HibernateException | |
|---|---|
Session |
JTASessionContext.currentSession()
|
Session |
ThreadLocalSessionContext.currentSession()
|
| Uses of HibernateException in org.hibernate.context.spi |
|---|
| Methods in org.hibernate.context.spi that throw HibernateException | |
|---|---|
Session |
CurrentSessionContext.currentSession()
Retrieve the current session according to the scoping defined by this implementation. |
| Uses of HibernateException in org.hibernate.criterion |
|---|
| Methods in org.hibernate.criterion that throw HibernateException | |
|---|---|
protected void |
Example.addComponentTypedValues(String path,
Object component,
CompositeType type,
List list,
Criteria criteria,
CriteriaQuery criteriaQuery)
|
protected void |
Example.appendComponentCondition(String path,
Object component,
CompositeType type,
Criteria criteria,
CriteriaQuery criteriaQuery,
StringBuilder buf)
|
protected void |
Example.appendPropertyCondition(String propertyName,
Object propertyValue,
Criteria criteria,
CriteriaQuery cq,
StringBuilder buf)
|
DetachedCriteria |
DetachedCriteria.createAlias(String associationPath,
String alias)
|
DetachedCriteria |
DetachedCriteria.createAlias(String associationPath,
String alias,
int joinType)
Deprecated. use DetachedCriteria.createAlias(String, String, JoinType) |
DetachedCriteria |
DetachedCriteria.createAlias(String associationPath,
String alias,
int joinType,
Criterion withClause)
Deprecated. use DetachedCriteria.createAlias(String, String, JoinType, Criterion) |
DetachedCriteria |
DetachedCriteria.createAlias(String associationPath,
String alias,
JoinType joinType)
|
DetachedCriteria |
DetachedCriteria.createAlias(String associationPath,
String alias,
JoinType joinType,
Criterion withClause)
|
DetachedCriteria |
DetachedCriteria.createCriteria(String associationPath)
|
DetachedCriteria |
DetachedCriteria.createCriteria(String associationPath,
int joinType)
Deprecated. use DetachedCriteria.createCriteria(String, JoinType) |
DetachedCriteria |
DetachedCriteria.createCriteria(String associationPath,
JoinType joinType)
|
DetachedCriteria |
DetachedCriteria.createCriteria(String associationPath,
String alias)
|
DetachedCriteria |
DetachedCriteria.createCriteria(String associationPath,
String alias,
int joinType)
Deprecated. use DetachedCriteria.createCriteria(String, String, JoinType) |
DetachedCriteria |
DetachedCriteria.createCriteria(String associationPath,
String alias,
int joinType,
Criterion withClause)
Deprecated. use DetachedCriteria.createCriteria(String, String, JoinType, Criterion) |
DetachedCriteria |
DetachedCriteria.createCriteria(String associationPath,
String alias,
JoinType joinType)
|
DetachedCriteria |
DetachedCriteria.createCriteria(String associationPath,
String alias,
JoinType joinType,
Criterion withClause)
|
String[] |
CriteriaQuery.findColumns(String propertyPath,
Criteria criteria)
Get the names of the columns mapped by a property path; if the property path is not found in criteria, try the "outer" query. |
String |
CriteriaQuery.getColumn(Criteria criteria,
String propertyPath)
Get the names of the columns mapped by a property path, ignoring projection aliases |
String[] |
CriteriaQuery.getColumns(String propertyPath,
Criteria criteria)
Get the names of the columns mapped by a property path, ignoring projection aliases |
String[] |
CriteriaQuery.getColumnsUsingProjection(Criteria criteria,
String propertyPath)
Get the names of the columns mapped by a property path |
protected QueryableCollection |
AbstractEmptinessExpression.getQueryableCollection(String entityName,
String propertyName,
SessionFactoryImplementor factory)
|
Type |
CriteriaQuery.getType(Criteria criteria,
String propertyPath)
Get the type of a property path, ignoring projection aliases |
TypedValue |
CriteriaQuery.getTypedValue(Criteria criteria,
String propertyPath,
Object value)
Get the a typed value for the given property value. |
TypedValue[] |
NotExpression.getTypedValues(Criteria criteria,
CriteriaQuery criteriaQuery)
|
TypedValue[] |
IdentifierEqExpression.getTypedValues(Criteria criteria,
CriteriaQuery criteriaQuery)
|
TypedValue[] |
Criterion.getTypedValues(Criteria criteria,
CriteriaQuery criteriaQuery)
Return typed values for all parameters in the rendered SQL fragment |
TypedValue[] |
LikeExpression.getTypedValues(Criteria criteria,
CriteriaQuery criteriaQuery)
|
TypedValue[] |
IlikeExpression.getTypedValues(Criteria criteria,
CriteriaQuery criteriaQuery)
Deprecated. |
TypedValue[] |
SubqueryExpression.getTypedValues(Criteria criteria,
CriteriaQuery criteriaQuery)
|
TypedValue[] |
InExpression.getTypedValues(Criteria criteria,
CriteriaQuery criteriaQuery)
|
TypedValue[] |
BetweenExpression.getTypedValues(Criteria criteria,
CriteriaQuery criteriaQuery)
|
TypedValue[] |
Junction.getTypedValues(Criteria crit,
CriteriaQuery criteriaQuery)
|
TypedValue[] |
AbstractEmptinessExpression.getTypedValues(Criteria criteria,
CriteriaQuery criteriaQuery)
|
TypedValue[] |
NaturalIdentifier.getTypedValues(Criteria criteria,
CriteriaQuery criteriaQuery)
|
TypedValue[] |
NullExpression.getTypedValues(Criteria criteria,
CriteriaQuery criteriaQuery)
|
TypedValue[] |
SimpleSubqueryExpression.getTypedValues(Criteria criteria,
CriteriaQuery criteriaQuery)
|
TypedValue[] |
SQLCriterion.getTypedValues(Criteria criteria,
CriteriaQuery criteriaQuery)
|
TypedValue[] |
Example.getTypedValues(Criteria criteria,
CriteriaQuery criteriaQuery)
|
TypedValue[] |
PropertyExpression.getTypedValues(Criteria criteria,
CriteriaQuery criteriaQuery)
|
TypedValue[] |
SizeExpression.getTypedValues(Criteria criteria,
CriteriaQuery criteriaQuery)
|
TypedValue[] |
LogicalExpression.getTypedValues(Criteria criteria,
CriteriaQuery criteriaQuery)
|
TypedValue[] |
NotNullExpression.getTypedValues(Criteria criteria,
CriteriaQuery criteriaQuery)
|
TypedValue[] |
SimpleExpression.getTypedValues(Criteria criteria,
CriteriaQuery criteriaQuery)
|
Type[] |
AliasedProjection.getTypes(Criteria criteria,
CriteriaQuery criteriaQuery)
|
Type[] |
Distinct.getTypes(Criteria criteria,
CriteriaQuery criteriaQuery)
|
Type[] |
SQLProjection.getTypes(Criteria crit,
CriteriaQuery criteriaQuery)
|
Type[] |
Projection.getTypes(Criteria criteria,
CriteriaQuery criteriaQuery)
Types returned by the rendered SQL fragment. |
Type[] |
AggregateProjection.getTypes(Criteria criteria,
CriteriaQuery criteriaQuery)
Types returned by the rendered SQL fragment. |
Type[] |
IdentifierProjection.getTypes(Criteria criteria,
CriteriaQuery criteriaQuery)
|
Type[] |
ProjectionList.getTypes(Criteria criteria,
CriteriaQuery criteriaQuery)
|
Type[] |
RowCountProjection.getTypes(Criteria criteria,
CriteriaQuery criteriaQuery)
|
Type[] |
PropertyProjection.getTypes(Criteria criteria,
CriteriaQuery criteriaQuery)
|
Type[] |
AliasedProjection.getTypes(String alias,
Criteria criteria,
CriteriaQuery criteriaQuery)
|
Type[] |
Distinct.getTypes(String alias,
Criteria criteria,
CriteriaQuery criteriaQuery)
|
Type[] |
Projection.getTypes(String alias,
Criteria criteria,
CriteriaQuery criteriaQuery)
Get the return types for a particular user-visible alias. |
Type |
CriteriaQuery.getTypeUsingProjection(Criteria criteria,
String propertyPath)
Get the type of a property path |
DetachedCriteria |
DetachedCriteria.setFetchMode(String associationPath,
FetchMode mode)
|
String |
Distinct.toGroupSqlString(Criteria criteria,
CriteriaQuery criteriaQuery)
|
String |
SQLProjection.toGroupSqlString(Criteria criteria,
CriteriaQuery criteriaQuery)
|
String |
Projection.toGroupSqlString(Criteria criteria,
CriteriaQuery criteriaQuery)
Render the SQL fragment to be used in the GROUP BY clause |
String |
IdentifierProjection.toGroupSqlString(Criteria criteria,
CriteriaQuery criteriaQuery)
|
String |
ProjectionList.toGroupSqlString(Criteria criteria,
CriteriaQuery criteriaQuery)
|
String |
PropertyProjection.toGroupSqlString(Criteria criteria,
CriteriaQuery criteriaQuery)
|
String |
NotExpression.toSqlString(Criteria criteria,
CriteriaQuery criteriaQuery)
|
String |
IdentifierEqExpression.toSqlString(Criteria criteria,
CriteriaQuery criteriaQuery)
|
String |
Criterion.toSqlString(Criteria criteria,
CriteriaQuery criteriaQuery)
Render the SQL fragment |
String |
LikeExpression.toSqlString(Criteria criteria,
CriteriaQuery criteriaQuery)
|
String |
IlikeExpression.toSqlString(Criteria criteria,
CriteriaQuery criteriaQuery)
Deprecated. |
String |
SubqueryExpression.toSqlString(Criteria criteria,
CriteriaQuery criteriaQuery)
|
String |
InExpression.toSqlString(Criteria criteria,
CriteriaQuery criteriaQuery)
|
String |
BetweenExpression.toSqlString(Criteria criteria,
CriteriaQuery criteriaQuery)
|
String |
Junction.toSqlString(Criteria crit,
CriteriaQuery criteriaQuery)
|
String |
AbstractEmptinessExpression.toSqlString(Criteria criteria,
CriteriaQuery criteriaQuery)
|
String |
NaturalIdentifier.toSqlString(Criteria criteria,
CriteriaQuery criteriaQuery)
|
String |
NullExpression.toSqlString(Criteria criteria,
CriteriaQuery criteriaQuery)
|
String |
SQLCriterion.toSqlString(Criteria criteria,
CriteriaQuery criteriaQuery)
|
String |
Example.toSqlString(Criteria criteria,
CriteriaQuery criteriaQuery)
|
String |
PropertyExpression.toSqlString(Criteria criteria,
CriteriaQuery criteriaQuery)
|
String |
SizeExpression.toSqlString(Criteria criteria,
CriteriaQuery criteriaQuery)
|
String |
LogicalExpression.toSqlString(Criteria criteria,
CriteriaQuery criteriaQuery)
|
String |
NotNullExpression.toSqlString(Criteria criteria,
CriteriaQuery criteriaQuery)
|
String |
SimpleExpression.toSqlString(Criteria criteria,
CriteriaQuery criteriaQuery)
|
String |
Order.toSqlString(Criteria criteria,
CriteriaQuery criteriaQuery)
Render the SQL fragment |
String |
AliasedProjection.toSqlString(Criteria criteria,
int position,
CriteriaQuery criteriaQuery)
|
String |
Distinct.toSqlString(Criteria criteria,
int position,
CriteriaQuery criteriaQuery)
|
String |
SQLProjection.toSqlString(Criteria criteria,
int loc,
CriteriaQuery criteriaQuery)
|
String |
Projection.toSqlString(Criteria criteria,
int position,
CriteriaQuery criteriaQuery)
Render the SQL fragment to be used in the SELECT clause. |
String |
AggregateProjection.toSqlString(Criteria criteria,
int loc,
CriteriaQuery criteriaQuery)
Render the SQL fragment to be used in the SELECT clause. |
String |
IdentifierProjection.toSqlString(Criteria criteria,
int position,
CriteriaQuery criteriaQuery)
|
String |
ProjectionList.toSqlString(Criteria criteria,
int loc,
CriteriaQuery criteriaQuery)
|
String |
RowCountProjection.toSqlString(Criteria criteria,
int position,
CriteriaQuery criteriaQuery)
|
String |
PropertyProjection.toSqlString(Criteria criteria,
int position,
CriteriaQuery criteriaQuery)
|
| Uses of HibernateException in org.hibernate.dialect |
|---|
| Methods in org.hibernate.dialect that throw HibernateException | |
|---|---|
static Dialect |
Dialect.getDialect()
Get an instance of the dialect specified by the current System properties. |
static Dialect |
Dialect.getDialect(Properties props)
Get an instance of the dialect specified by the given properties or by the current System properties. |
String |
Dialect.getHibernateTypeName(int code)
Get the name of the Hibernate Type associated with the given
Types type code. |
String |
Dialect.getHibernateTypeName(int code,
int length,
int precision,
int scale)
Get the name of the Hibernate Type associated
with the given Types typecode with the given storage
specification parameters. |
String |
Dialect.getTypeName(int code)
Get the name of the database type associated with the given Types typecode. |
String |
TeradataDialect.getTypeName(int code,
int length,
int precision,
int scale)
Get the name of the database type associated with the given java.sql.Types typecode. |
String |
Dialect.getTypeName(int code,
long length,
int precision,
int scale)
Get the name of the database type associated with the given Types typecode with the given storage specification
parameters. |
| Uses of HibernateException in org.hibernate.dialect.lock |
|---|
| Subclasses of HibernateException in org.hibernate.dialect.lock | |
|---|---|
class |
LockingStrategyException
Represents an error trying to apply a LockingStrategy to an entity |
class |
OptimisticEntityLockException
Represents an error trying to apply an optimistic LockingStrategy to an entity |
class |
PessimisticEntityLockException
Represents an error trying to apply a pessimistic LockingStrategy to an entity |
| Uses of HibernateException in org.hibernate.ejb |
|---|
| Methods in org.hibernate.ejb with parameters of type HibernateException | |
|---|---|
RuntimeException |
HibernateEntityManagerImplementor.convert(HibernateException e)
Converts a Hibernate-specific exception into a JPA-specified exception; note that the JPA sepcification makes use of exceptions outside its exception hierarchy, though they are all runtime exceptions. |
RuntimeException |
AbstractEntityManagerImpl.convert(HibernateException e)
Converts a Hibernate-specific exception into a JPA-specified exception; note that the JPA sepcification makes use of exceptions outside its exception hierarchy, though they are all runtime exceptions. |
RuntimeException |
HibernateEntityManagerImplementor.convert(HibernateException e,
LockOptions lockOptions)
Converts a Hibernate-specific exception into a JPA-specified exception; note that the JPA sepcification makes use of exceptions outside its exception hierarchy, though they are all runtime exceptions. |
RuntimeException |
AbstractEntityManagerImpl.convert(HibernateException e,
LockOptions lockOptions)
Converts a Hibernate-specific exception into a JPA-specified exception; note that the JPA sepcification makes use of exceptions outside its exception hierarchy, though they are all runtime exceptions. |
void |
HibernateEntityManagerImplementor.throwPersistenceException(HibernateException e)
Delegates to HibernateEntityManagerImplementor.convert(org.hibernate.HibernateException, org.hibernate.LockOptions) and then throws the given exception. |
void |
AbstractEntityManagerImpl.throwPersistenceException(HibernateException e)
Delegates to HibernateEntityManagerImplementor.convert(org.hibernate.HibernateException, org.hibernate.LockOptions) and then throws the given exception. |
PersistenceException |
AbstractEntityManagerImpl.wrapLockException(HibernateException e,
LockOptions lockOptions)
|
| Methods in org.hibernate.ejb that throw HibernateException | |
|---|---|
Ejb3Configuration |
Ejb3Configuration.configure(String resource)
Deprecated. |
| Uses of HibernateException in org.hibernate.ejb.connection |
|---|
| Methods in org.hibernate.ejb.connection that throw HibernateException | |
|---|---|
void |
InjectedDataSourceConnectionProvider.configure(Properties props)
|
| Uses of HibernateException in org.hibernate.ejb.internal |
|---|
| Methods in org.hibernate.ejb.internal with parameters of type HibernateException | |
|---|---|
void |
EntityManagerMessageLogger_$logger.namedQueryError(String arg0,
HibernateException arg1)
|
void |
EntityManagerMessageLogger_$logger.unableToCloseSession(HibernateException arg0)
|
void |
EntityManagerMessageLogger_$logger.unableToCloseSessionButSwallowingError(HibernateException arg0)
|
void |
EntityManagerMessageLogger_$logger.unableToConfigureSqlExceptionConverter(HibernateException arg0)
|
void |
EntityManagerMessageLogger_$logger.unableToCreateProxyFactory(String arg0,
HibernateException arg1)
|
void |
EntityManagerMessageLogger_$logger.unableToLoadCommand(HibernateException arg0)
|
void |
EntityManagerMessageLogger_$logger.unableToSynchronizeDatabaseStateWithSession(HibernateException arg0)
|
| Methods in org.hibernate.ejb.internal that throw HibernateException | |
|---|---|
EntityManagerFactory |
EntityManagerFactoryRegistry.getNamedEntityManagerFactory(String name)
Lookup the specified entity manager factory by name |
void |
EntityManagerFactoryRegistry.removeEntityManagerFactory(String name,
EntityManagerFactory entityManagerFactory)
remove the specified entity manager factory from the EntityManagerFactoryRegistry |
| Uses of HibernateException in org.hibernate.engine.internal |
|---|
| Methods in org.hibernate.engine.internal that throw HibernateException | |
|---|---|
CollectionEntry |
StatefulPersistenceContext.addInitializedCollection(CollectionPersister persister,
PersistentCollection collection,
Serializable id)
add a collection we just pulled out of the cache (does not need initializing) |
void |
StatefulPersistenceContext.addInitializedDetachedCollection(CollectionPersister collectionPersister,
PersistentCollection collection)
add an (initialized) collection that was created by another session and passed into update() (ie. |
void |
StatefulPersistenceContext.addNewCollection(CollectionPersister persister,
PersistentCollection collection)
Add a new collection (ie. |
static int |
ParameterBinder.bindNamedParameters(PreparedStatement ps,
Map namedParams,
int start,
ParameterBinder.NamedParameterSource source,
SessionImplementor session)
|
static int |
ParameterBinder.bindNamedParameters(PreparedStatement ps,
QueryParameters queryParameters,
int start,
ParameterBinder.NamedParameterSource source,
SessionImplementor session)
|
static int |
ParameterBinder.bindPositionalParameters(PreparedStatement st,
Object[] values,
Type[] types,
int start,
SessionImplementor session)
|
static int |
ParameterBinder.bindPositionalParameters(PreparedStatement st,
QueryParameters queryParameters,
int start,
SessionImplementor session)
|
static int |
ParameterBinder.bindQueryParameters(PreparedStatement st,
QueryParameters queryParameters,
int start,
ParameterBinder.NamedParameterSource source,
SessionImplementor session)
|
void |
Cascade.cascade(EntityPersister persister,
Object parent)
Cascade an action from the parent entity instance to all its children. |
void |
Cascade.cascade(EntityPersister persister,
Object parent,
Object anything)
Cascade an action from the parent entity instance to all its children. |
void |
Nullability.checkNullability(Object[] values,
EntityPersister persister,
boolean isUpdate)
Check nullability of the class persister properties |
void |
StatefulPersistenceContext.checkUniqueness(EntityKey key,
Object object)
Attempts to check whether the given key represents an entity already loaded within the current session. |
Object[] |
StatefulPersistenceContext.getDatabaseSnapshot(Serializable id,
EntityPersister persister)
Get the current state of the entity as known to the underlying database, or null if there is no corresponding row |
static Serializable |
ForeignKeys.getEntityIdentifierIfNotUnsaved(String entityName,
Object object,
SessionImplementor session)
Return the identifier of the persistent or transient object, or throw an exception if the instance is "unsaved" Used by OneToOneType and ManyToOneType to determine what id value should be used for an object that may or may not be associated with the session. |
Object[] |
StatefulPersistenceContext.getNaturalIdSnapshot(Serializable id,
EntityPersister persister)
|
static void |
TwoPhaseLoad.initializeEntity(Object entity,
boolean readOnly,
SessionImplementor session,
PreLoadEvent preLoadEvent,
PostLoadEvent postLoadEvent)
Perform the second step of 2-phase load. |
void |
StatefulPersistenceContext.initializeNonLazyCollections()
Force initialization of all non-lazy collections encountered during the current two-phase load (actually, this is a no-op, unless this is the "outermost" load) |
static boolean |
ForeignKeys.isNotTransient(String entityName,
Object entity,
Boolean assumed,
SessionImplementor session)
Is this instance persistent or detached? If assumed is non-null, don't hit the database to make the determination, instead assume that value; the client code must be prepared to "recover" in the case that this assumed result is incorrect. |
static boolean |
ForeignKeys.isTransient(String entityName,
Object entity,
Boolean assumed,
SessionImplementor session)
Is this instance, which we know is not persistent, actually transient? If assumed is non-null, don't hit the database to make the determination, instead assume that value; the client code must be prepared to "recover" in the case that this assumed result is incorrect. |
Object |
StatefulPersistenceContext.narrowProxy(Object proxy,
EntityPersister persister,
EntityKey key,
Object object)
If the existing proxy is insufficiently "narrow" (derived), instantiate a new proxy and overwrite the registration of the old one. |
void |
ForeignKeys.Nullifier.nullifyTransientReferences(Object[] values,
Type[] types)
Nullify all references to entities that have not yet been inserted in the database, where the foreign key points toward that entity |
static void |
TwoPhaseLoad.postHydrate(EntityPersister persister,
Serializable id,
Object[] values,
Object rowId,
Object object,
LockMode lockMode,
boolean lazyPropertiesAreUnfetched,
SessionImplementor session)
Register the "hydrated" state of an entity instance, after the first step of 2-phase loading. |
Object |
StatefulPersistenceContext.proxyFor(EntityPersister persister,
EntityKey key,
Object impl)
Return the existing proxy associated with the given EntityKey, or the third argument (the entity associated with the key) if no proxy exists. |
Object |
StatefulPersistenceContext.proxyFor(Object impl)
Return the existing proxy associated with the given EntityKey, or the argument (the entity associated with the key) if no proxy exists. |
Object |
StatefulPersistenceContext.unproxy(Object maybeProxy)
Get the entity instance underlying the given proxy, throwing an exception if the proxy is uninitialized. |
Object |
StatefulPersistenceContext.unproxyAndReassociate(Object maybeProxy)
Possibly unproxy the given reference and reassociate it with the current session. |
| Uses of HibernateException in org.hibernate.engine.jdbc.internal |
|---|
| Methods in org.hibernate.engine.jdbc.internal that throw HibernateException | |
|---|---|
Connection |
LogicalConnectionImpl.getConnection()
|
| Uses of HibernateException in org.hibernate.engine.jdbc.internal.proxy |
|---|
| Subclasses of HibernateException in org.hibernate.engine.jdbc.internal.proxy | |
|---|---|
class |
JdbcProxyException
Indicates a problem defining or instantiating a JDBC proxy class. |
| Uses of HibernateException in org.hibernate.engine.query.spi |
|---|
| Methods in org.hibernate.engine.query.spi that throw HibernateException | |
|---|---|
int |
HQLQueryPlan.performExecuteUpdate(QueryParameters queryParameters,
SessionImplementor session)
|
int |
NativeSQLQueryPlan.performExecuteUpdate(QueryParameters queryParameters,
SessionImplementor session)
|
Iterator |
HQLQueryPlan.performIterate(QueryParameters queryParameters,
EventSource session)
|
List |
HQLQueryPlan.performList(QueryParameters queryParameters,
SessionImplementor session)
|
ScrollableResults |
HQLQueryPlan.performScroll(QueryParameters queryParameters,
SessionImplementor session)
|
| Uses of HibernateException in org.hibernate.engine.spi |
|---|
| Methods in org.hibernate.engine.spi that throw HibernateException | |
|---|---|
CollectionEntry |
PersistenceContext.addInitializedCollection(CollectionPersister persister,
PersistentCollection collection,
Serializable id)
add a collection we just pulled out of the cache (does not need initializing) |
void |
PersistenceContext.addInitializedDetachedCollection(CollectionPersister collectionPersister,
PersistentCollection collection)
add an (initialized) collection that was created by another session and passed into update() (ie. |
void |
PersistenceContext.addNewCollection(CollectionPersister persister,
PersistentCollection collection)
Add a new collection (ie. |
void |
SessionImplementor.applyNonFlushedChanges(NonFlushedChanges nonFlushedChanges)
Apply non-flushed changes from a different session to this session. |
abstract void |
CascadingAction.cascade(EventSource session,
Object child,
String entityName,
Object anything,
boolean isCascadeDeleteEnabled)
Cascade the action to the child object. |
void |
PersistenceContext.checkUniqueness(EntityKey key,
Object object)
Attempts to check whether the given key represents an entity already loaded within the current session. |
void |
ActionQueue.executeActions()
Perform all currently queued actions. |
void |
ActionQueue.executeInserts()
Perform all currently queued entity-insertion actions. |
int |
SessionImplementor.executeNativeUpdate(NativeSQLQuerySpecification specification,
QueryParameters queryParameters)
Execute a native SQL update or delete query |
int |
SessionImplementor.executeUpdate(String query,
QueryParameters queryParameters)
Execute a HQL update or delete query |
EntityPersister |
SessionImplementor.getEntityPersister(String entityName,
Object object)
Get the EntityPersister for any instance |
Object |
SessionImplementor.getEntityUsingInterceptor(EntityKey key)
Get the entity instance associated with the given Key, calling the Interceptor if necessary |
NonFlushedChanges |
SessionImplementor.getNonFlushedChanges()
Return changes to this session that have not been flushed yet. |
Collection |
CollectionEntry.getOrphans(String entityName,
PersistentCollection collection)
Get the collection orphans (entities which were removed from the collection) |
QueryCache |
SessionFactoryImplementor.getQueryCache(String regionName)
Get a particular named query cache, or the default cache |
String[] |
SessionFactoryImplementor.getReturnAliases(String queryString)
Get the return aliases of a query |
Type[] |
SessionFactoryImplementor.getReturnTypes(String queryString)
Get the return types of a query |
String |
SessionImplementor.guessEntityName(Object entity)
The guessed entity name for an entity not in an association |
Object |
SessionImplementor.immediateLoad(String entityName,
Serializable id)
Load an instance immediately. |
void |
SessionImplementor.initializeCollection(PersistentCollection collection,
boolean writing)
Initialize the collection (if not already initialized) |
void |
PersistenceContext.initializeNonLazyCollections()
Force initialization of all non-lazy collections encountered during the current two-phase load (actually, this is a no-op, unless this is the "outermost" load) |
Object |
SessionImplementor.instantiate(String entityName,
Serializable id)
Instantiate the entity class, initializing with the given identifier |
Object |
SessionImplementor.internalLoad(String entityName,
Serializable id,
boolean eager,
boolean nullable)
Load an instance without checking if it was deleted. |
Iterator |
SessionImplementor.iterate(String query,
QueryParameters queryParameters)
Execute an iterate() query |
Iterator |
SessionImplementor.iterateFilter(Object collection,
String filter,
QueryParameters queryParameters)
Iterate a filter |
List |
SessionImplementor.list(NativeSQLQuerySpecification spec,
QueryParameters queryParameters)
Execute a native SQL query, and return the results as a fully built list. |
List |
SessionImplementor.list(String query,
QueryParameters queryParameters)
Execute a find() query |
List |
SessionImplementor.listCustomQuery(CustomQuery customQuery,
QueryParameters queryParameters)
Execute an SQL Query |
List |
SessionImplementor.listFilter(Object collection,
String filter,
QueryParameters queryParameters)
Execute a filter |
Object |
PersistenceContext.narrowProxy(Object proxy,
EntityPersister persister,
EntityKey key,
Object object)
If the existing proxy is insufficiently "narrow" (derived), instantiate a new proxy and overwrite the registration of the old one. |
Session |
SessionFactoryImplementor.openTemporarySession()
Get a nontransactional "current" session for Hibernate EntityManager |
void |
CollectionEntry.postFlush(PersistentCollection collection)
Called after a successful flush |
void |
CollectionEntry.postInitialize(PersistentCollection collection)
|
void |
CollectionEntry.preFlush(PersistentCollection collection)
|
void |
ActionQueue.prepareActions()
Prepares the internal action queues for execution. |
Object |
PersistenceContext.proxyFor(EntityPersister persister,
EntityKey key,
Object impl)
Return the existing proxy associated with the given EntityKey, or the third argument (the entity associated with the key) if no proxy exists. |
Object |
PersistenceContext.proxyFor(Object impl)
Return the existing proxy associated with the given EntityKey, or the argument (the entity associated with the key) if no proxy exists. |
ScrollableResults |
SessionImplementor.scroll(NativeSQLQuerySpecification spec,
QueryParameters queryParameters)
Execute a native SQL query, and return the results as a scrollable result. |
ScrollableResults |
SessionImplementor.scroll(String query,
QueryParameters queryParameters)
Execute a scroll() query |
ScrollableResults |
SessionImplementor.scrollCustomQuery(CustomQuery customQuery,
QueryParameters queryParameters)
Execute an SQL Query |
void |
QueryParameters.traceParameters(SessionFactoryImplementor factory)
|
Object |
PersistenceContext.unproxy(Object maybeProxy)
Get the entity instance underlying the given proxy, throwing an exception if the proxy is uninitialized. |
Object |
PersistenceContext.unproxyAndReassociate(Object maybeProxy)
Possibly unproxy the given reference and reassociate it with the current session. |
| Uses of HibernateException in org.hibernate.engine.transaction.internal |
|---|
| Subclasses of HibernateException in org.hibernate.engine.transaction.internal | |
|---|---|
class |
NullSynchronizationException
Indicates an attempt to register a null synchronization. |
| Uses of HibernateException in org.hibernate.engine.transaction.internal.jdbc |
|---|
| Methods in org.hibernate.engine.transaction.internal.jdbc that throw HibernateException | ||
|---|---|---|
|
JdbcIsolationDelegate.delegateWork(WorkExecutorVisitable<T> work,
boolean transacted)
|
|
boolean |
JdbcTransaction.isActive()
|
|
| Uses of HibernateException in org.hibernate.engine.transaction.internal.jta |
|---|
| Methods in org.hibernate.engine.transaction.internal.jta that throw HibernateException | ||
|---|---|---|
|
JtaIsolationDelegate.delegateWork(WorkExecutorVisitable<T> work,
boolean transacted)
|
|
boolean |
JtaTransaction.isActive()
|
|
| Uses of HibernateException in org.hibernate.engine.transaction.spi |
|---|
| Methods in org.hibernate.engine.transaction.spi that throw HibernateException | ||
|---|---|---|
void |
AbstractTransactionImpl.begin()
|
|
void |
AbstractTransactionImpl.commit()
|
|
|
IsolationDelegate.delegateWork(WorkExecutorVisitable<T> work,
boolean transacted)
Perform the given work in isolation from current transaction. |
|
void |
AbstractTransactionImpl.rollback()
|
|
boolean |
AbstractTransactionImpl.wasRolledBack()
|
|
| Uses of HibernateException in org.hibernate.envers |
|---|
| Methods in org.hibernate.envers that throw HibernateException | |
|---|---|
String |
AuditReader.getEntityName(Object primaryKey,
Number revision,
Object entity)
|
| Uses of HibernateException in org.hibernate.envers.entities |
|---|
| Methods in org.hibernate.envers.entities that throw HibernateException | |
|---|---|
Object |
RevisionTypeType.assemble(Serializable cached,
Object owner)
|
Object |
RevisionTypeType.deepCopy(Object value)
|
Serializable |
RevisionTypeType.disassemble(Object value)
|
boolean |
RevisionTypeType.equals(Object x,
Object y)
|
int |
RevisionTypeType.hashCode(Object x)
|
RevisionType |
RevisionTypeType.nullSafeGet(ResultSet resultSet,
String[] names,
SessionImplementor session,
Object owner)
|
void |
RevisionTypeType.nullSafeSet(PreparedStatement preparedStatement,
Object value,
int index,
SessionImplementor session)
|
Object |
RevisionTypeType.replace(Object original,
Object target,
Object owner)
|
| Uses of HibernateException in org.hibernate.envers.entities.mapper.relation.lazy |
|---|
| Methods in org.hibernate.envers.entities.mapper.relation.lazy that throw HibernateException | |
|---|---|
void |
AbstractDelegateSessionImplementor.applyNonFlushedChanges(NonFlushedChanges nonFlushedChanges)
|
Object |
ToOneDelegateSessionImplementor.doImmediateLoad(String entityName)
|
int |
AbstractDelegateSessionImplementor.executeNativeUpdate(NativeSQLQuerySpecification specification,
QueryParameters queryParameters)
|
int |
AbstractDelegateSessionImplementor.executeUpdate(String query,
QueryParameters queryParameters)
|
EntityPersister |
AbstractDelegateSessionImplementor.getEntityPersister(String entityName,
Object object)
|
Object |
AbstractDelegateSessionImplementor.getEntityUsingInterceptor(EntityKey key)
|
NonFlushedChanges |
AbstractDelegateSessionImplementor.getNonFlushedChanges()
|
String |
AbstractDelegateSessionImplementor.guessEntityName(Object entity)
|
Object |
AbstractDelegateSessionImplementor.immediateLoad(String entityName,
Serializable id)
|
void |
AbstractDelegateSessionImplementor.initializeCollection(PersistentCollection collection,
boolean writing)
|
Object |
AbstractDelegateSessionImplementor.instantiate(String entityName,
Serializable id)
|
Object |
AbstractDelegateSessionImplementor.internalLoad(String entityName,
Serializable id,
boolean eager,
boolean nullable)
|
Iterator |
AbstractDelegateSessionImplementor.iterate(String query,
QueryParameters queryParameters)
|
Iterator |
AbstractDelegateSessionImplementor.iterateFilter(Object collection,
String filter,
QueryParameters queryParameters)
|
List |
AbstractDelegateSessionImplementor.list(NativeSQLQuerySpecification spec,
QueryParameters queryParameters)
|
List |
AbstractDelegateSessionImplementor.list(String query,
QueryParameters queryParameters)
|
List |
AbstractDelegateSessionImplementor.listCustomQuery(CustomQuery customQuery,
QueryParameters queryParameters)
|
List |
AbstractDelegateSessionImplementor.listFilter(Object collection,
String filter,
QueryParameters queryParameters)
|
ScrollableResults |
AbstractDelegateSessionImplementor.scroll(NativeSQLQuerySpecification spec,
QueryParameters queryParameters)
|
ScrollableResults |
AbstractDelegateSessionImplementor.scroll(String query,
QueryParameters queryParameters)
|
ScrollableResults |
AbstractDelegateSessionImplementor.scrollCustomQuery(CustomQuery customQuery,
QueryParameters queryParameters)
|
| Uses of HibernateException in org.hibernate.envers.exception |
|---|
| Subclasses of HibernateException in org.hibernate.envers.exception | |
|---|---|
class |
AuditException
|
class |
NotAuditedException
|
class |
RevisionDoesNotExistException
|
| Uses of HibernateException in org.hibernate.envers.internal |
|---|
| Methods in org.hibernate.envers.internal with parameters of type HibernateException | |
|---|---|
void |
EnversMessageLogger_$logger.namedQueryError(String arg0,
HibernateException arg1)
|
void |
EnversMessageLogger_$logger.unableToCloseSession(HibernateException arg0)
|
void |
EnversMessageLogger_$logger.unableToCloseSessionButSwallowingError(HibernateException arg0)
|
void |
EnversMessageLogger_$logger.unableToConfigureSqlExceptionConverter(HibernateException arg0)
|
void |
EnversMessageLogger_$logger.unableToCreateProxyFactory(String arg0,
HibernateException arg1)
|
void |
EnversMessageLogger_$logger.unableToLoadCommand(HibernateException arg0)
|
void |
EnversMessageLogger_$logger.unableToSynchronizeDatabaseStateWithSession(HibernateException arg0)
|
| Uses of HibernateException in org.hibernate.envers.reader |
|---|
| Methods in org.hibernate.envers.reader that throw HibernateException | |
|---|---|
String |
AuditReaderImpl.getEntityName(Object primaryKey,
Number revision,
Object entity)
|
| Uses of HibernateException in org.hibernate.event.internal |
|---|
| Methods in org.hibernate.event.internal that throw HibernateException | |
|---|---|
protected void |
DefaultDeleteEventListener.cascadeAfterDelete(EventSource session,
EntityPersister persister,
Object entity,
Set transientEntities)
|
protected void |
DefaultMergeEventListener.cascadeAfterSave(EventSource source,
EntityPersister persister,
Object entity,
Object anything)
Cascade behavior is redefined by this subclass, disable superclass behavior |
protected void |
DefaultDeleteEventListener.cascadeBeforeDelete(EventSource session,
EntityPersister persister,
Object entity,
EntityEntry entityEntry,
Set transientEntities)
|
protected void |
DefaultMergeEventListener.cascadeBeforeSave(EventSource source,
EntityPersister persister,
Object entity,
Object anything)
Cascade behavior is redefined by this subclass, disable superclass behavior |
void |
DefaultFlushEntityEventListener.checkId(Object object,
EntityPersister persister,
Serializable id,
SessionImplementor session)
make sure user didn't mangle the id |
protected void |
DefaultFlushEntityEventListener.dirtyCheck(FlushEntityEvent event)
Perform a dirty check, and attach the results to the event |
protected void |
DefaultEvictEventListener.doEvict(Object object,
EntityKey key,
EntityPersister persister,
EventSource session)
|
protected Serializable |
DefaultSaveOrUpdateEventListener.entityIsPersistent(SaveOrUpdateEvent event)
|
protected void |
AbstractFlushingEventListener.flushEverythingToExecutions(FlushEvent event)
Coordinates the processing necessary to get things ready for executions as db calls by preping the session caches and moving the appropriate entities and collections to their respective execution queues. |
protected Serializable |
DefaultUpdateEventListener.getUpdateId(Object entity,
EntityPersister persister,
Serializable requestedId,
SessionImplementor session)
If the user specified an id, assign it to the instance and use that, otherwise use the id already assigned to the instance |
protected boolean |
DefaultFlushEntityEventListener.isUpdateNecessary(FlushEntityEvent event)
Performs all necessary checking to determine if an entity needs an SQL update to synchronize its state to the database. |
protected Object |
DefaultLoadEventListener.loadFromSessionCache(LoadEvent event,
EntityKey keyToLoad,
LoadEventListener.LoadType options)
Attempts to locate the entity in the session-level cache. |
void |
DefaultAutoFlushEventListener.onAutoFlush(AutoFlushEvent event)
Handle the given auto-flush event. |
void |
DefaultDeleteEventListener.onDelete(DeleteEvent event)
Handle the given delete event. |
void |
DefaultDeleteEventListener.onDelete(DeleteEvent event,
Set transientEntities)
Handle the given delete event. |
void |
DefaultDirtyCheckEventListener.onDirtyCheck(DirtyCheckEvent event)
Handle the given dirty-check event. |
void |
DefaultEvictEventListener.onEvict(EvictEvent event)
Handle the given evict event. |
void |
DefaultFlushEventListener.onFlush(FlushEvent event)
Handle the given flush event. |
void |
DefaultFlushEntityEventListener.onFlushEntity(FlushEntityEvent event)
Flushes a single entity's state to the database, by scheduling an update action, if necessary |
void |
DefaultInitializeCollectionEventListener.onInitializeCollection(InitializeCollectionEvent event)
called by a collection that wants to initialize itself |
void |
DefaultLoadEventListener.onLoad(LoadEvent event,
LoadEventListener.LoadType loadType)
Handle the given load event. |
void |
DefaultLockEventListener.onLock(LockEvent event)
Handle the given lock event. |
void |
DefaultMergeEventListener.onMerge(MergeEvent event)
Handle the given merge event. |
void |
DefaultMergeEventListener.onMerge(MergeEvent event,
Map copiedAlready)
Handle the given merge event. |
void |
DefaultPersistEventListener.onPersist(PersistEvent event)
Handle the given create event. |
void |
DefaultPersistEventListener.onPersist(PersistEvent event,
Map createCache)
Handle the given create event. |
void |
DefaultRefreshEventListener.onRefresh(RefreshEvent event)
|
void |
DefaultResolveNaturalIdEventListener.onResolveNaturalId(ResolveNaturalIdEvent event)
|
protected void |
DefaultSaveOrUpdateEventListener.performUpdate(SaveOrUpdateEvent event,
Object entity,
EntityPersister persister)
|
protected void |
AbstractFlushingEventListener.postFlush(SessionImplementor session)
1. |
void |
AbstractVisitor.processEntityPropertyValues(Object[] values,
Type[] types)
Dispatch each property value to processValue(). |
protected void |
ProxyVisitor.reattachCollection(PersistentCollection collection,
CollectionType type)
Reattach a detached (disassociated) initialized or uninitialized collection wrapper, using a snapshot carried with the collection wrapper |
| Uses of HibernateException in org.hibernate.event.service.spi |
|---|
| Subclasses of HibernateException in org.hibernate.event.service.spi | |
|---|---|
class |
EventListenerRegistrationException
Indicates a problem registering an event listener. |
| Uses of HibernateException in org.hibernate.event.spi |
|---|
| Methods in org.hibernate.event.spi that throw HibernateException | |
|---|---|
void |
EventSource.forceFlush(EntityEntry e)
Force an immediate flush |
Object |
EventSource.instantiate(EntityPersister persister,
Serializable id)
Instantiate an entity instance, using either an interceptor, or the given persister |
void |
EventSource.merge(String entityName,
Object object,
Map copiedAlready)
Cascade merge an entity instance |
void |
AutoFlushEventListener.onAutoFlush(AutoFlushEvent event)
Handle the given auto-flush event. |
void |
DeleteEventListener.onDelete(DeleteEvent event)
Handle the given delete event. |
void |
DeleteEventListener.onDelete(DeleteEvent event,
Set transientEntities)
|
void |
DirtyCheckEventListener.onDirtyCheck(DirtyCheckEvent event)
Handle the given dirty-check event. |
void |
EvictEventListener.onEvict(EvictEvent event)
Handle the given evict event. |
void |
FlushEventListener.onFlush(FlushEvent event)
Handle the given flush event. |
void |
FlushEntityEventListener.onFlushEntity(FlushEntityEvent event)
|
void |
InitializeCollectionEventListener.onInitializeCollection(InitializeCollectionEvent event)
|
void |
LoadEventListener.onLoad(LoadEvent event,
LoadEventListener.LoadType loadType)
Handle the given load event. |
void |
LockEventListener.onLock(LockEvent event)
Handle the given lock event. |
void |
MergeEventListener.onMerge(MergeEvent event)
Handle the given merge event. |
void |
MergeEventListener.onMerge(MergeEvent event,
Map copiedAlready)
Handle the given merge event. |
void |
PersistEventListener.onPersist(PersistEvent event)
Handle the given create event. |
void |
PersistEventListener.onPersist(PersistEvent event,
Map createdAlready)
Handle the given create event. |
void |
RefreshEventListener.onRefresh(RefreshEvent event)
Handle the given refresh event. |
void |
RefreshEventListener.onRefresh(RefreshEvent event,
Map refreshedAlready)
|
void |
ReplicateEventListener.onReplicate(ReplicateEvent event)
Handle the given replicate event. |
void |
ResolveNaturalIdEventListener.onResolveNaturalId(ResolveNaturalIdEvent event)
Handle the given resolve natural id event. |
void |
SaveOrUpdateEventListener.onSaveOrUpdate(SaveOrUpdateEvent event)
Handle the given update event. |
void |
EventSource.persist(String entityName,
Object object,
Map createdAlready)
Cascade persist an entity instance |
void |
EventSource.refresh(Object object,
Map refreshedAlready)
Cascade refresh an entity instance |
| Uses of HibernateException in org.hibernate.exception |
|---|
| Subclasses of HibernateException in org.hibernate.exception | |
|---|---|
class |
ConstraintViolationException
Implementation of JDBCException indicating that the requested DML operation resulted in a violation of a defined integrity constraint. |
class |
DataException
Implementation of JDBCException indicating that evaluation of the valid SQL statement against the given data resulted in some illegal operation, mismatched types or incorrect cardinality. |
class |
GenericJDBCException
Generic, non-specific JDBCException. |
class |
JDBCConnectionException
Implementation of JDBCException indicating problems with communicating with the database (can also include incorrect JDBC setup). |
class |
LockAcquisitionException
Implementation of JDBCException indicating a problem acquiring lock on the database. |
class |
LockTimeoutException
|
class |
SQLGrammarException
Implementation of JDBCException indicating that the SQL sent to the database server was invalid (syntax error, invalid object references, etc). |
| Uses of HibernateException in org.hibernate.exception.spi |
|---|
| Methods in org.hibernate.exception.spi that throw HibernateException | |
|---|---|
static SQLExceptionConverter |
SQLExceptionConverterFactory.buildSQLExceptionConverter(Dialect dialect,
Properties properties)
Build a SQLExceptionConverter instance. |
void |
Configurable.configure(Properties properties)
Configure the component, using the given settings and properties. |
| Uses of HibernateException in org.hibernate.hql.internal |
|---|
| Subclasses of HibernateException in org.hibernate.hql.internal | |
|---|---|
class |
QueryExecutionRequestException
Expecting to execute an illegal operation regarding the query type |
| Uses of HibernateException in org.hibernate.hql.internal.ast |
|---|
| Subclasses of HibernateException in org.hibernate.hql.internal.ast | |
|---|---|
class |
InvalidWithClauseException
Indicates an issue with the encountered with-clause. |
class |
QuerySyntaxException
Exception thrown when there is a syntax error in the HQL. |
| Methods in org.hibernate.hql.internal.ast that throw HibernateException | |
|---|---|
int |
QueryTranslatorImpl.executeUpdate(QueryParameters queryParameters,
SessionImplementor session)
|
Iterator |
QueryTranslatorImpl.iterate(QueryParameters queryParameters,
EventSource session)
Return the query results as an iterator |
List |
QueryTranslatorImpl.list(SessionImplementor session,
QueryParameters queryParameters)
|
ScrollableResults |
QueryTranslatorImpl.scroll(QueryParameters queryParameters,
SessionImplementor session)
Return the query results, as an instance of ScrollableResults |
void |
QueryTranslatorImpl.validateScrollability()
|
| Uses of HibernateException in org.hibernate.hql.internal.ast.exec |
|---|
| Methods in org.hibernate.hql.internal.ast.exec that throw HibernateException | |
|---|---|
int |
MultiTableDeleteExecutor.execute(QueryParameters parameters,
SessionImplementor session)
|
int |
MultiTableUpdateExecutor.execute(QueryParameters parameters,
SessionImplementor session)
|
int |
BasicExecutor.execute(QueryParameters parameters,
SessionImplementor session)
|
int |
StatementExecutor.execute(QueryParameters parameters,
SessionImplementor session)
Execute the sql managed by this executor using the given parameters. |
| Uses of HibernateException in org.hibernate.hql.internal.classic |
|---|
| Methods in org.hibernate.hql.internal.classic that throw HibernateException | |
|---|---|
int |
QueryTranslatorImpl.executeUpdate(QueryParameters queryParameters,
SessionImplementor session)
|
protected Object |
QueryTranslatorImpl.getResultColumnOrRow(Object[] row,
ResultTransformer transformer,
ResultSet rs,
SessionImplementor session)
|
protected Object[] |
QueryTranslatorImpl.getResultRow(Object[] row,
ResultSet rs,
SessionImplementor session)
|
Iterator |
QueryTranslatorImpl.iterate(QueryParameters queryParameters,
EventSource session)
Return the query results as an iterator |
List |
QueryTranslatorImpl.list(SessionImplementor session,
QueryParameters queryParameters)
|
ScrollableResults |
QueryTranslatorImpl.scroll(QueryParameters queryParameters,
SessionImplementor session)
|
void |
QueryTranslatorImpl.validateScrollability()
|
| Uses of HibernateException in org.hibernate.hql.spi |
|---|
| Methods in org.hibernate.hql.spi that throw HibernateException | |
|---|---|
int |
QueryTranslator.executeUpdate(QueryParameters queryParameters,
SessionImplementor session)
Perform a bulk update/delete operation given the underlying query definition. |
Iterator |
QueryTranslator.iterate(QueryParameters queryParameters,
EventSource session)
Perform an iterate operation given the underlying query definition. |
List |
QueryTranslator.list(SessionImplementor session,
QueryParameters queryParameters)
Perform a list operation given the underlying query definition. |
ScrollableResults |
QueryTranslator.scroll(QueryParameters queryParameters,
SessionImplementor session)
Perform a scroll operation given the underlying query definition. |
void |
QueryTranslator.validateScrollability()
Validate the scrollability of the translated query. |
| Uses of HibernateException in org.hibernate.id |
|---|
| Subclasses of HibernateException in org.hibernate.id | |
|---|---|
class |
IdentifierGenerationException
Thrown by IdentifierGenerator implementation class when ID generation fails. |
| Methods in org.hibernate.id that throw HibernateException | |
|---|---|
Serializable |
IdentifierGenerator.generate(SessionImplementor session,
Object object)
Generate a new identifier. |
Serializable |
IncrementGenerator.generate(SessionImplementor session,
Object object)
|
Serializable |
CompositeNestedGeneratedValueGenerator.generate(SessionImplementor session,
Object object)
|
Serializable |
UUIDGenerator.generate(SessionImplementor session,
Object object)
|
Serializable |
Assigned.generate(SessionImplementor session,
Object obj)
|
Serializable |
GUIDGenerator.generate(SessionImplementor session,
Object obj)
|
static Serializable |
IdentifierGeneratorHelper.getGeneratedIdentity(ResultSet rs,
String identifier,
Type type)
Get the generated identifier when using identity columns |
InsertGeneratedIdentifierDelegate |
IdentityGenerator.getInsertGeneratedIdentifierDelegate(PostInsertIdentityPersister persister,
Dialect dialect,
boolean isGetGeneratedKeysEnabled)
|
InsertGeneratedIdentifierDelegate |
SelectGenerator.getInsertGeneratedIdentifierDelegate(PostInsertIdentityPersister persister,
Dialect dialect,
boolean isGetGeneratedKeysEnabled)
|
InsertGeneratedIdentifierDelegate |
SequenceIdentityGenerator.getInsertGeneratedIdentifierDelegate(PostInsertIdentityPersister persister,
Dialect dialect,
boolean isGetGeneratedKeysEnabled)
|
InsertGeneratedIdentifierDelegate |
PostInsertIdentifierGenerator.getInsertGeneratedIdentifierDelegate(PostInsertIdentityPersister persister,
Dialect dialect,
boolean isGetGeneratedKeysEnabled)
|
String[] |
MultipleHiLoPerTableGenerator.sqlCreateStrings(Dialect dialect)
|
String[] |
TableGenerator.sqlCreateStrings(Dialect dialect)
|
String[] |
PersistentIdentifierGenerator.sqlCreateStrings(Dialect dialect)
The SQL required to create the underlying database objects. |
String[] |
SequenceGenerator.sqlCreateStrings(Dialect dialect)
|
String[] |
MultipleHiLoPerTableGenerator.sqlDropStrings(Dialect dialect)
|
String[] |
PersistentIdentifierGenerator.sqlDropStrings(Dialect dialect)
The SQL required to remove the underlying database objects. |
String[] |
SequenceGenerator.sqlDropStrings(Dialect dialect)
|
| Uses of HibernateException in org.hibernate.id.enhanced |
|---|
| Methods in org.hibernate.id.enhanced that throw HibernateException | |
|---|---|
Serializable |
SequenceStyleGenerator.generate(SessionImplementor session,
Object object)
|
String[] |
SequenceStructure.sqlCreateStrings(Dialect dialect)
|
String[] |
TableGenerator.sqlCreateStrings(Dialect dialect)
|
String[] |
SequenceStyleGenerator.sqlCreateStrings(Dialect dialect)
|
String[] |
TableStructure.sqlCreateStrings(Dialect dialect)
|
String[] |
SequenceStructure.sqlDropStrings(Dialect dialect)
|
String[] |
TableGenerator.sqlDropStrings(Dialect dialect)
|
String[] |
SequenceStyleGenerator.sqlDropStrings(Dialect dialect)
|
String[] |
TableStructure.sqlDropStrings(Dialect dialect)
|
| Uses of HibernateException in org.hibernate.internal |
|---|
| Methods in org.hibernate.internal that throw HibernateException | ||
|---|---|---|
void |
ScrollableResultsImpl.afterLast()
|
|
void |
FetchingScrollableResultsImpl.afterLast()
Go to a location just after the last result |
|
void |
SessionImpl.applyNonFlushedChanges(NonFlushedChanges nonFlushedChanges)
Apply non-flushed changes from a different session to this session. |
|
protected boolean |
SessionImpl.autoFlushIfRequired(Set querySpaces)
detect in-memory changes, determine if the changes are to tables named in the query and, if so, complete execution the flush |
|
void |
ScrollableResultsImpl.beforeFirst()
|
|
void |
FetchingScrollableResultsImpl.beforeFirst()
Go to a location just before first result (this is the initial location) |
|
Transaction |
StatelessSessionImpl.beginTransaction()
|
|
Transaction |
SessionImpl.beginTransaction()
|
|
void |
SessionImpl.cancelQuery()
|
|
void |
AbstractScrollableResults.close()
|
|
Connection |
SessionImpl.close()
|
|
void |
SessionFactoryImpl.close()
Closes the session factory, releasing all held resources. |
|
Connection |
SessionImpl.connection()
|
|
Criteria |
CriteriaImpl.createAlias(String associationPath,
String alias,
int joinType)
|
|
Criteria |
CriteriaImpl.Subcriteria.createAlias(String associationPath,
String alias,
int joinType)
|
|
Criteria |
CriteriaImpl.createAlias(String associationPath,
String alias,
int joinType,
Criterion withClause)
|
|
Criteria |
CriteriaImpl.Subcriteria.createAlias(String associationPath,
String alias,
int joinType,
Criterion withClause)
|
|
Criteria |
CriteriaImpl.Subcriteria.createAlias(String associationPath,
String alias,
JoinType joinType)
|
|
Criteria |
CriteriaImpl.Subcriteria.createAlias(String associationPath,
String alias,
JoinType joinType,
Criterion withClause)
|
|
Criteria |
CriteriaImpl.createCriteria(String associationPath,
int joinType)
|
|
Criteria |
CriteriaImpl.Subcriteria.createCriteria(String associationPath,
int joinType)
|
|
Criteria |
CriteriaImpl.Subcriteria.createCriteria(String associationPath,
JoinType joinType)
|
|
Criteria |
CriteriaImpl.createCriteria(String associationPath,
String alias,
int joinType)
|
|
Criteria |
CriteriaImpl.Subcriteria.createCriteria(String associationPath,
String alias,
int joinType)
|
|
Criteria |
CriteriaImpl.createCriteria(String associationPath,
String alias,
int joinType,
Criterion withClause)
|
|
Criteria |
CriteriaImpl.Subcriteria.createCriteria(String associationPath,
String alias,
int joinType,
Criterion withClause)
|
|
Criteria |
CriteriaImpl.Subcriteria.createCriteria(String associationPath,
String alias,
JoinType joinType)
|
|
Criteria |
CriteriaImpl.Subcriteria.createCriteria(String associationPath,
String alias,
JoinType joinType,
Criterion withClause)
|
|
void |
SessionImpl.delete(Object object)
Delete a persistent object |
|
void |
SessionImpl.delete(String entityName,
Object object)
Delete a persistent object (by explicit entity name) |
|
void |
SessionImpl.delete(String entityName,
Object object,
boolean isCascadeDeleteEnabled,
Set transientEntities)
Delete a persistent object |
|
protected Type |
AbstractQueryImpl.determineType(int paramPosition,
Object paramValue)
|
|
protected Type |
AbstractQueryImpl.determineType(String paramName,
Class clazz)
|
|
protected Type |
AbstractQueryImpl.determineType(String paramName,
Object paramValue)
|
|
Connection |
SessionImpl.disconnect()
|
|
|
SessionImpl.doReturningWork(ReturningWork<T> work)
|
|
void |
SessionImpl.doWork(Work work)
|
|
void |
SessionFactoryImpl.evict(Class persistentClass)
|
|
void |
SessionFactoryImpl.evict(Class persistentClass,
Serializable id)
|
|
void |
SessionImpl.evict(Object object)
remove any hard references to the entity that are held by the infrastructure (references held by application or other persistant instances are okay) |
|
void |
SessionFactoryImpl.evictCollection(String roleName)
|
|
void |
SessionFactoryImpl.evictCollection(String roleName,
Serializable id)
|
|
void |
SessionFactoryImpl.evictEntity(String entityName)
|
|
void |
SessionFactoryImpl.evictEntity(String entityName,
Serializable id)
|
|
void |
SessionFactoryImpl.evictQueries()
|
|
void |
SessionFactoryImpl.evictQueries(String regionName)
|
|
int |
StatelessSessionImpl.executeNativeUpdate(NativeSQLQuerySpecification nativeSQLQuerySpecification,
QueryParameters queryParameters)
|
|
int |
SessionImpl.executeNativeUpdate(NativeSQLQuerySpecification nativeQuerySpecification,
QueryParameters queryParameters)
|
|
int |
QueryImpl.executeUpdate()
|
|
int |
SQLQueryImpl.executeUpdate()
|
|
int |
StatelessSessionImpl.executeUpdate(String query,
QueryParameters queryParameters)
|
|
int |
SessionImpl.executeUpdate(String query,
QueryParameters queryParameters)
|
|
boolean |
ScrollableResultsImpl.first()
|
|
boolean |
FetchingScrollableResultsImpl.first()
Go to the first result |
|
void |
SessionImpl.flush()
|
|
void |
SessionImpl.forceFlush(EntityEntry entityEntry)
|
|
Object[] |
AbstractScrollableResults.get()
|
|
Object |
SessionImpl.get(Class entityClass,
Serializable id)
|
|
Object |
SessionImpl.get(Class entityClass,
Serializable id,
LockMode lockMode)
|
|
Object |
SessionImpl.get(Class entityClass,
Serializable id,
LockOptions lockOptions)
|
|
Object |
AbstractScrollableResults.get(int col)
|
|
Object |
SessionImpl.get(String entityName,
Serializable id)
|
|
Object |
SessionImpl.get(String entityName,
Serializable id,
LockMode lockMode)
|
|
Object |
SessionImpl.get(String entityName,
Serializable id,
LockOptions lockOptions)
|
|
Map<String,ClassMetadata> |
SessionFactoryImpl.getAllClassMetadata()
|
|
Map |
SessionFactoryImpl.getAllCollectionMetadata()
|
|
BigDecimal |
AbstractScrollableResults.getBigDecimal(int col)
|
|
BigInteger |
AbstractScrollableResults.getBigInteger(int col)
|
|
byte[] |
AbstractScrollableResults.getBinary(int col)
|
|
Blob |
AbstractScrollableResults.getBlob(int col)
|
|
Boolean |
AbstractScrollableResults.getBoolean(int col)
|
|
Byte |
AbstractScrollableResults.getByte(int col)
|
|
Calendar |
AbstractScrollableResults.getCalendar(int col)
|
|
Character |
AbstractScrollableResults.getCharacter(int col)
|
|
ClassMetadata |
SessionFactoryImpl.getClassMetadata(Class persistentClass)
|
|
ClassMetadata |
SessionFactoryImpl.getClassMetadata(String entityName)
|
|
Clob |
AbstractScrollableResults.getClob(int col)
|
|
CollectionMetadata |
SessionFactoryImpl.getCollectionMetadata(String roleName)
|
|
LockMode |
SessionImpl.getCurrentLockMode(Object object)
|
|
Session |
SessionFactoryImpl.getCurrentSession()
|
|
Date |
AbstractScrollableResults.getDate(int col)
|
|
Double |
AbstractScrollableResults.getDouble(int col)
|
|
EntityPersister |
StatelessSessionImpl.getEntityPersister(String entityName,
Object object)
|
|
Object |
StatelessSessionImpl.getEntityUsingInterceptor(EntityKey key)
|
|
Object |
SessionImpl.getEntityUsingInterceptor(EntityKey key)
|
|
FilterDefinition |
SessionFactoryImpl.getFilterDefinition(String filterName)
|
|
protected Object |
AbstractScrollableResults.getFinal(int col,
Type returnType)
Check that the requested type is compatible with the result type, and return the column value. |
|
Float |
AbstractScrollableResults.getFloat(int col)
|
|
protected HQLQueryPlan |
AbstractSessionImpl.getHQLQueryPlan(String query,
boolean shallow)
|
|
Serializable |
SessionImpl.getIdentifier(Object object)
|
|
Integer |
AbstractScrollableResults.getInteger(int col)
|
|
Locale |
AbstractScrollableResults.getLocale(int col)
|
|
Long |
AbstractScrollableResults.getLong(int col)
|
|
String[] |
AbstractQueryImpl.getNamedParameters()
Returns an array representing all named parameter names encountered during (intial) parsing of the query. |
|
protected NativeSQLQueryPlan |
AbstractSessionImpl.getNativeSQLQueryPlan(NativeSQLQuerySpecification spec)
|
|
protected Object |
AbstractScrollableResults.getNonFinal(int col,
Type returnType)
Check that the requested type is compatible with the result type, and return the column value. |
|
NonFlushedChanges |
SessionImpl.getNonFlushedChanges()
Return changes to this session and its child sessions that have not been flushed yet. |
|
QueryCache |
SessionFactoryImpl.getQueryCache(String regionName)
|
|
String[] |
SQLQueryImpl.getReturnAliases()
|
|
String[] |
AbstractQueryImpl.getReturnAliases()
|
|
String[] |
SessionFactoryImpl.getReturnAliases(String queryString)
|
|
Type[] |
SQLQueryImpl.getReturnTypes()
|
|
Type[] |
AbstractQueryImpl.getReturnTypes()
|
|
Type[] |
SessionFactoryImpl.getReturnTypes(String queryString)
|
|
int |
ScrollableResultsImpl.getRowNumber()
|
|
int |
FetchingScrollableResultsImpl.getRowNumber()
Get the current location in the result set. |
|
Short |
AbstractScrollableResults.getShort(int col)
|
|
String |
AbstractScrollableResults.getString(int col)
|
|
String |
AbstractScrollableResults.getText(int col)
|
|
TimeZone |
AbstractScrollableResults.getTimeZone(int col)
|
|
Transaction |
StatelessSessionImpl.getTransaction()
|
|
Transaction |
SessionImpl.getTransaction()
|
|
String |
StatelessSessionImpl.guessEntityName(Object entity)
|
|
String |
SessionImpl.guessEntityName(Object object)
|
|
Object |
StatelessSessionImpl.immediateLoad(String entityName,
Serializable id)
|
|
Object |
SessionImpl.immediateLoad(String entityName,
Serializable id)
Load the data for the object with the specified id into a newly created object. |
|
void |
StatelessSessionImpl.initializeCollection(PersistentCollection collection,
boolean writing)
|
|
void |
SessionImpl.initializeCollection(PersistentCollection collection,
boolean writing)
|
|
Object |
SessionImpl.instantiate(EntityPersister persister,
Serializable id)
give the interceptor an opportunity to override the default instantiation |
|
Object |
StatelessSessionImpl.instantiate(String entityName,
Serializable id)
|
|
Object |
SessionImpl.instantiate(String entityName,
Serializable id)
|
|
Object |
StatelessSessionImpl.internalLoad(String entityName,
Serializable id,
boolean eager,
boolean nullable)
|
|
Object |
SessionImpl.internalLoad(String entityName,
Serializable id,
boolean eager,
boolean nullable)
|
|
boolean |
SessionImpl.isDirty()
|
|
boolean |
ScrollableResultsImpl.isFirst()
|
|
boolean |
FetchingScrollableResultsImpl.isFirst()
Is this the first result? |
|
boolean |
ScrollableResultsImpl.isLast()
|
|
boolean |
FetchingScrollableResultsImpl.isLast()
Is this the last result? |
|
Iterator |
QueryImpl.iterate()
|
|
Iterator |
CollectionFilterImpl.iterate()
|
|
Iterator |
SQLQueryImpl.iterate()
|
|
Iterator |
StatelessSessionImpl.iterate(String query,
QueryParameters queryParameters)
|
|
Iterator |
SessionImpl.iterate(String query,
QueryParameters queryParameters)
|
|
Iterator |
StatelessSessionImpl.iterateFilter(Object collection,
String filter,
QueryParameters queryParameters)
|
|
Iterator |
SessionImpl.iterateFilter(Object collection,
String filter,
QueryParameters queryParameters)
|
|
boolean |
ScrollableResultsImpl.last()
|
|
boolean |
FetchingScrollableResultsImpl.last()
Go to the last result |
|
List |
CriteriaImpl.list()
|
|
List |
CriteriaImpl.Subcriteria.list()
|
|
List |
QueryImpl.list()
|
|
List |
CollectionFilterImpl.list()
|
|
List |
SQLQueryImpl.list()
|
|
List |
StatelessSessionImpl.list(CriteriaImpl criteria)
|
|
List |
SessionImpl.list(CriteriaImpl criteria)
|
|
List |
AbstractSessionImpl.list(NativeSQLQuerySpecification spec,
QueryParameters queryParameters)
|
|
List |
StatelessSessionImpl.list(String query,
QueryParameters queryParameters)
|
|
List |
SessionImpl.list(String query,
QueryParameters queryParameters)
|
|
List |
StatelessSessionImpl.listCustomQuery(CustomQuery customQuery,
QueryParameters queryParameters)
|
|
List |
SessionImpl.listCustomQuery(CustomQuery customQuery,
QueryParameters queryParameters)
|
|
List |
StatelessSessionImpl.listFilter(Object collection,
String filter,
QueryParameters queryParameters)
|
|
List |
SessionImpl.listFilter(Object collection,
String filter,
QueryParameters queryParameters)
|
|
Object |
SessionImpl.load(Class entityClass,
Serializable id)
|
|
Object |
SessionImpl.load(Class entityClass,
Serializable id,
LockMode lockMode)
|
|
Object |
SessionImpl.load(Class entityClass,
Serializable id,
LockOptions lockOptions)
|
|
void |
SessionImpl.load(Object object,
Serializable id)
|
|
Object |
SessionImpl.load(String entityName,
Serializable id)
|
|
Object |
SessionImpl.load(String entityName,
Serializable id,
LockMode lockMode)
|
|
Object |
SessionImpl.load(String entityName,
Serializable id,
LockOptions lockOptions)
|
|
void |
SessionImpl.lock(Object object,
LockMode lockMode)
|
|
void |
SessionImpl.lock(String entityName,
Object object,
LockMode lockMode)
|
|
Object |
SessionImpl.merge(Object object)
|
|
Object |
SessionImpl.merge(String entityName,
Object object)
|
|
void |
SessionImpl.merge(String entityName,
Object object,
Map copiedAlready)
|
|
boolean |
ScrollableResultsImpl.next()
|
|
boolean |
FetchingScrollableResultsImpl.next()
Advance to the next result |
|
Object |
IteratorImpl.next()
|
|
Session |
SessionFactoryImpl.openSession()
|
|
Session |
SessionFactoryImpl.openTemporarySession()
|
|
void |
SessionImpl.persist(Object object)
|
|
void |
SessionImpl.persist(String entityName,
Object object)
|
|
void |
SessionImpl.persist(String entityName,
Object object,
Map copiedAlready)
|
|
void |
SessionImpl.persistOnFlush(Object object)
|
|
void |
SessionImpl.persistOnFlush(String entityName,
Object object)
|
|
void |
SessionImpl.persistOnFlush(String entityName,
Object object,
Map copiedAlready)
|
|
boolean |
ScrollableResultsImpl.previous()
|
|
boolean |
FetchingScrollableResultsImpl.previous()
Retreat to the previous result |
|
void |
SessionImpl.reconnect(Connection conn)
|
|
void |
SessionImpl.refresh(Object object)
|
|
void |
SessionImpl.refresh(Object object,
LockMode lockMode)
|
|
void |
SessionImpl.refresh(Object object,
LockOptions lockOptions)
|
|
void |
SessionImpl.refresh(Object object,
Map refreshedAlready)
|
|
void |
SessionImpl.refresh(String entityName,
Object object)
|
|
void |
SessionImpl.refresh(String entityName,
Object object,
LockOptions lockOptions)
|
|
void |
SessionImpl.replicate(Object obj,
ReplicationMode replicationMode)
|
|
void |
SessionImpl.replicate(String entityName,
Object obj,
ReplicationMode replicationMode)
|
|
Serializable |
SessionImpl.save(Object obj)
|
|
Serializable |
SessionImpl.save(String entityName,
Object object)
|
|
void |
SessionImpl.saveOrUpdate(Object object)
|
|
void |
SessionImpl.saveOrUpdate(String entityName,
Object obj)
|
|
ScrollableResults |
CriteriaImpl.Subcriteria.scroll()
|
|
ScrollableResults |
QueryImpl.scroll()
|
|
ScrollableResults |
CollectionFilterImpl.scroll()
|
|
ScrollableResults |
SQLQueryImpl.scroll()
|
|
boolean |
ScrollableResultsImpl.scroll(int i)
|
|
boolean |
FetchingScrollableResultsImpl.scroll(int positions)
Scroll an arbitrary number of locations |
|
ScrollableResults |
AbstractSessionImpl.scroll(NativeSQLQuerySpecification spec,
QueryParameters queryParameters)
|
|
ScrollableResults |
CriteriaImpl.Subcriteria.scroll(ScrollMode scrollMode)
|
|
ScrollableResults |
QueryImpl.scroll(ScrollMode scrollMode)
|
|
ScrollableResults |
SQLQueryImpl.scroll(ScrollMode scrollMode)
|
|
ScrollableResults |
StatelessSessionImpl.scroll(String query,
QueryParameters queryParameters)
|
|
ScrollableResults |
SessionImpl.scroll(String query,
QueryParameters queryParameters)
|
|
ScrollableResults |
StatelessSessionImpl.scrollCustomQuery(CustomQuery customQuery,
QueryParameters queryParameters)
|
|
ScrollableResults |
SessionImpl.scrollCustomQuery(CustomQuery customQuery,
QueryParameters queryParameters)
|
|
void |
StatelessSessionImpl.setDefaultReadOnly(boolean readOnly)
|
|
Query |
AbstractQueryImpl.setParameter(int position,
Object val)
|
|
Query |
AbstractQueryImpl.setParameter(String name,
Object val)
|
|
Filter |
FilterImpl.setParameterList(String name,
Collection values)
Set the named parameter's value list for this filter. |
|
Query |
AbstractQueryImpl.setParameterList(String name,
Collection vals)
|
|
Query |
AbstractQueryImpl.setParameterList(String name,
Collection vals,
Type type)
|
|
Query |
AbstractQueryImpl.setParameterList(String name,
Object[] vals)
|
|
Query |
AbstractQueryImpl.setParameterList(String name,
Object[] vals,
Type type)
|
|
Query |
AbstractQueryImpl.setProperties(Map map)
|
|
Query |
AbstractQueryImpl.setProperties(Object bean)
|
|
boolean |
ScrollableResultsImpl.setRowNumber(int rowNumber)
|
|
boolean |
FetchingScrollableResultsImpl.setRowNumber(int rowNumber)
Set the current location in the result set, numbered from either the first row (row number 0), or the last row (row number -1). |
|
Object |
CriteriaImpl.uniqueResult()
|
|
Object |
CriteriaImpl.Subcriteria.uniqueResult()
|
|
Object |
AbstractQueryImpl.uniqueResult()
|
|
void |
SessionImpl.update(Object obj)
|
|
void |
SessionImpl.update(String entityName,
Object object)
|
|
void |
FilterImpl.validate()
Perform validation of the filter state. |
|
protected void |
AbstractQueryImpl.verifyParameters(boolean reserveFirstParameter)
Perform parameter validation. |
|
| Constructors in org.hibernate.internal that throw HibernateException | |
|---|---|
IteratorImpl(ResultSet rs,
PreparedStatement ps,
EventSource sess,
boolean readOnly,
Type[] types,
String[][] columnNames,
HolderInstantiator holderInstantiator)
|
|
SessionFactoryImpl(Configuration cfg,
Mapping mapping,
ServiceRegistry serviceRegistry,
Settings settings,
SessionFactoryObserver observer)
|
|
SessionFactoryImpl(MetadataImplementor metadata,
SessionFactory.SessionFactoryOptions sessionFactoryOptions,
SessionFactoryObserver observer)
|
|
| Uses of HibernateException in org.hibernate.internal.util |
|---|
| Methods in org.hibernate.internal.util that throw HibernateException | |
|---|---|
static Properties |
ConfigHelper.getConfigProperties(String path)
Loads a properties instance based on the data at the incoming config location. |
static InputStream |
ConfigHelper.getConfigStream(String path)
Open an InputStream to the URL represented by the incoming path. |
static Reader |
ConfigHelper.getConfigStreamReader(String path)
Open an Reader to the URL represented by the incoming path. |
void |
EntityPrinter.toString(Iterable<Map.Entry<EntityKey,Object>> entitiesByEntityKey)
|
String |
EntityPrinter.toString(Map<String,TypedValue> namedTypedValues)
|
String |
EntityPrinter.toString(String entityName,
Object entity)
Renders an entity to a string. |
String |
EntityPrinter.toString(Type[] types,
Object[] values)
|
void |
Cloneable.validate()
Checks to ensure the SessionEventListenerConfig is fully configured (basically, that none of the listeners is null). |
| Uses of HibernateException in org.hibernate.internal.util.beans |
|---|
| Subclasses of HibernateException in org.hibernate.internal.util.beans | |
|---|---|
class |
BeanIntrospectionException
Indicates a problem dealing with BeanInfo via the BeanInfoHelper delegate. |
| Uses of HibernateException in org.hibernate.internal.util.config |
|---|
| Subclasses of HibernateException in org.hibernate.internal.util.config | |
|---|---|
class |
ConfigurationException
TODO : javadoc |
| Uses of HibernateException in org.hibernate.jdbc |
|---|
| Subclasses of HibernateException in org.hibernate.jdbc | |
|---|---|
class |
BatchedTooManyRowsAffectedException
Much like TooManyRowsAffectedException, indicates that more
rows than what we were expcecting were affected. |
class |
BatchFailedException
Indicates a failed batch entry (-3 return). |
class |
TooManyRowsAffectedException
Indicates that more rows were affected then we were expecting to be. |
| Methods in org.hibernate.jdbc that throw HibernateException | |
|---|---|
int |
Expectations.BasicExpectation.prepare(PreparedStatement statement)
|
int |
Expectations.BasicParamExpectation.prepare(PreparedStatement statement)
|
int |
Expectation.prepare(PreparedStatement statement)
Perform any special statement preparation. |
void |
Expectation.verifyOutcome(int rowCount,
PreparedStatement statement,
int batchPosition)
Perform verification of the outcome of the RDBMS operation based on the type of expectation defined. |
| Uses of HibernateException in org.hibernate.jmx |
|---|
| Methods in org.hibernate.jmx that throw HibernateException | |
|---|---|
void |
SessionFactoryStub.close()
Deprecated. |
void |
HibernateServiceMBean.createSchema()
Deprecated. Export the CREATE DDL to the database |
void |
HibernateServiceMBean.dropSchema()
Deprecated. Export the DROP DDL to the database |
void |
SessionFactoryStub.evict(Class persistentClass)
Deprecated. |
void |
SessionFactoryStub.evict(Class persistentClass,
Serializable id)
Deprecated. |
void |
SessionFactoryStub.evictCollection(String roleName)
Deprecated. |
void |
SessionFactoryStub.evictCollection(String roleName,
Serializable id)
Deprecated. |
void |
SessionFactoryStub.evictEntity(String entityName)
Deprecated. |
void |
SessionFactoryStub.evictEntity(String entityName,
Serializable id)
Deprecated. |
void |
SessionFactoryStub.evictQueries()
Deprecated. |
void |
SessionFactoryStub.evictQueries(String cacheRegion)
Deprecated. |
Map<String,ClassMetadata> |
SessionFactoryStub.getAllClassMetadata()
Deprecated. |
Map |
SessionFactoryStub.getAllCollectionMetadata()
Deprecated. |
ClassMetadata |
SessionFactoryStub.getClassMetadata(Class persistentClass)
Deprecated. |
ClassMetadata |
SessionFactoryStub.getClassMetadata(String entityName)
Deprecated. |
CollectionMetadata |
SessionFactoryStub.getCollectionMetadata(String roleName)
Deprecated. |
FilterDefinition |
SessionFactoryStub.getFilterDefinition(String filterName)
Deprecated. |
Session |
SessionFactoryStub.openSession()
Deprecated. |
void |
HibernateService.start()
Deprecated. |
void |
HibernateServiceMBean.start()
Deprecated. Create the SessionFactory and bind to the jndi name on startup |
| Uses of HibernateException in org.hibernate.loader |
|---|
| Subclasses of HibernateException in org.hibernate.loader | |
|---|---|
class |
MultipleBagFetchException
Exception used to indicate that a query is attempting to simultaneously fetch multiple bags |
| Methods in org.hibernate.loader that throw HibernateException | |
|---|---|
protected String |
Loader.applyLocks(String sql,
LockOptions lockOptions,
Dialect dialect)
Append FOR UPDATE OF clause, if necessary. |
protected int |
Loader.bindNamedParameters(PreparedStatement statement,
Map namedParams,
int startIndex,
SessionImplementor session)
Bind named parameters to the JDBC prepared statement. |
protected int |
Loader.bindPositionalParameters(PreparedStatement statement,
QueryParameters queryParameters,
int startIndex,
SessionImplementor session)
Bind positional parameter values to the JDBC prepared statement. |
protected void |
Loader.checkScrollability()
Check whether the current loader can support returning ScrollableResults. |
protected List |
Loader.doList(SessionImplementor session,
QueryParameters queryParameters)
Actually execute a query, ignoring the query cache |
protected Object |
Loader.getResultColumnOrRow(Object[] row,
ResultTransformer transformer,
ResultSet rs,
SessionImplementor session)
Get the actual object that is returned in the user-visible result list. |
protected Object[] |
Loader.getResultRow(Object[] row,
ResultSet rs,
SessionImplementor session)
|
protected ResultSet |
Loader.getResultSet(PreparedStatement st,
boolean autodiscovertypes,
boolean callable,
RowSelection selection,
SessionImplementor session)
Fetch a PreparedStatement, call setMaxRows and then execute it, advance to the first result and return an SQL ResultSet |
protected List |
Loader.list(SessionImplementor session,
QueryParameters queryParameters,
Set querySpaces,
Type[] resultTypes)
Return the query results, using the query cache, called by subclasses that implement cacheable queries |
void |
Loader.loadCollection(SessionImplementor session,
Serializable id,
Type type)
Called by subclasses that initialize collections |
void |
Loader.loadCollectionBatch(SessionImplementor session,
Serializable[] ids,
Type type)
Called by wrappers that batch initialize collections |
protected void |
Loader.loadCollectionSubselect(SessionImplementor session,
Serializable[] ids,
Object[] parameterValues,
Type[] parameterTypes,
Map namedParameters,
Type type)
Called by subclasses that batch initialize collections |
protected List |
Loader.loadEntity(SessionImplementor session,
Object key,
Object index,
Type keyType,
Type indexType,
EntityPersister persister)
Called by subclasses that load entities |
protected List |
Loader.loadEntity(SessionImplementor session,
Object id,
Type identifierType,
Object optionalObject,
String optionalEntityName,
Serializable optionalIdentifier,
EntityPersister persister,
LockOptions lockOptions)
Called by subclasses that load entities |
List |
Loader.loadEntityBatch(SessionImplementor session,
Serializable[] ids,
Type idType,
Object optionalObject,
String optionalEntityName,
Serializable optionalId,
EntityPersister persister,
LockOptions lockOptions)
Called by wrappers that batch load entities |
Object |
Loader.loadSequentialRowsForward(ResultSet resultSet,
SessionImplementor session,
QueryParameters queryParameters,
boolean returnProxies)
Loads a single logical row from the result set moving forward. |
Object |
Loader.loadSequentialRowsReverse(ResultSet resultSet,
SessionImplementor session,
QueryParameters queryParameters,
boolean returnProxies,
boolean isLogicallyAfterLast)
Loads a single logical row from the result set moving forward. |
Object |
Loader.loadSingleRow(ResultSet resultSet,
SessionImplementor session,
QueryParameters queryParameters,
boolean returnProxies)
Loads a single row from the result set. |
protected PreparedStatement |
Loader.prepareQueryStatement(QueryParameters queryParameters,
boolean scroll,
SessionImplementor session)
Obtain a PreparedStatement with all parameters pre-bound. |
protected String |
Loader.preprocessSQL(String sql,
QueryParameters parameters,
Dialect dialect)
Modify the SQL, adding lock hints and comments, if necessary |
protected ScrollableResults |
Loader.scroll(QueryParameters queryParameters,
Type[] returnTypes,
HolderInstantiator holderInstantiator,
SessionImplementor session)
Return the query results, as an instance of ScrollableResults |
| Uses of HibernateException in org.hibernate.loader.collection |
|---|
| Methods in org.hibernate.loader.collection that throw HibernateException | |
|---|---|
void |
CollectionInitializer.initialize(Serializable id,
SessionImplementor session)
Initialize the given collection |
void |
SubselectOneToManyLoader.initialize(Serializable id,
SessionImplementor session)
|
void |
SubselectCollectionLoader.initialize(Serializable id,
SessionImplementor session)
|
void |
CollectionLoader.initialize(Serializable id,
SessionImplementor session)
|
void |
BatchingCollectionInitializer.initialize(Serializable id,
SessionImplementor session)
|
| Uses of HibernateException in org.hibernate.loader.criteria |
|---|
| Methods in org.hibernate.loader.criteria that throw HibernateException | |
|---|---|
String[] |
CriteriaQueryTranslator.findColumns(String propertyName,
Criteria subcriteria)
Get the names of the columns mapped by a property path; if the property path is not found in subcriteria, try the "outer" query. |
String[] |
CriteriaQueryTranslator.getColumns(String propertyName,
Criteria subcriteria)
|
String[] |
CriteriaQueryTranslator.getColumnsUsingProjection(Criteria subcriteria,
String propertyName)
Get the names of the columns constrained by this criterion. |
protected Object |
CriteriaLoader.getResultColumnOrRow(Object[] row,
ResultTransformer transformer,
ResultSet rs,
SessionImplementor session)
|
protected Object[] |
CriteriaLoader.getResultRow(Object[] row,
ResultSet rs,
SessionImplementor session)
|
Type |
CriteriaQueryTranslator.getType(Criteria subcriteria,
String propertyName)
|
TypedValue |
CriteriaQueryTranslator.getTypedValue(Criteria subcriteria,
String propertyName,
Object value)
Get the a typed value for the given property value. |
Type |
CriteriaQueryTranslator.getTypeUsingProjection(Criteria subcriteria,
String propertyName)
|
List |
CriteriaLoader.list(SessionImplementor session)
|
ScrollableResults |
CriteriaLoader.scroll(SessionImplementor session,
ScrollMode scrollMode)
|
| Constructors in org.hibernate.loader.criteria that throw HibernateException | |
|---|---|
CriteriaLoader(OuterJoinLoadable persister,
SessionFactoryImplementor factory,
CriteriaImpl criteria,
String rootEntityName,
LoadQueryInfluencers loadQueryInfluencers)
|
|
CriteriaQueryTranslator(SessionFactoryImplementor factory,
CriteriaImpl criteria,
String rootEntityName,
String rootSQLAlias)
|
|
CriteriaQueryTranslator(SessionFactoryImplementor factory,
CriteriaImpl criteria,
String rootEntityName,
String rootSQLAlias,
CriteriaQuery outerQuery)
|
|
| Uses of HibernateException in org.hibernate.loader.custom |
|---|
| Subclasses of HibernateException in org.hibernate.loader.custom | |
|---|---|
class |
NonUniqueDiscoveredSqlAliasException
|
| Methods in org.hibernate.loader.custom that throw HibernateException | |
|---|---|
Object |
CustomLoader.ResultRowProcessor.buildResultRow(Object[] data,
ResultSet resultSet,
boolean hasTransformer,
SessionImplementor session)
Build a logical result row. |
Object[] |
CustomLoader.ResultRowProcessor.buildResultRow(Object[] data,
ResultSet resultSet,
SessionImplementor session)
|
Object |
CustomLoader.NonScalarResultColumnProcessor.extract(Object[] data,
ResultSet resultSet,
SessionImplementor session)
|
Object |
CustomLoader.ScalarResultColumnProcessor.extract(Object[] data,
ResultSet resultSet,
SessionImplementor session)
|
protected Object |
CustomLoader.getResultColumnOrRow(Object[] row,
ResultTransformer transformer,
ResultSet rs,
SessionImplementor session)
|
protected Object[] |
CustomLoader.getResultRow(Object[] row,
ResultSet rs,
SessionImplementor session)
|
List |
CustomLoader.list(SessionImplementor session,
QueryParameters queryParameters)
|
ScrollableResults |
CustomLoader.scroll(QueryParameters queryParameters,
SessionImplementor session)
|
| Uses of HibernateException in org.hibernate.loader.custom.sql |
|---|
| Constructors in org.hibernate.loader.custom.sql that throw HibernateException | |
|---|---|
SQLCustomQuery(String sqlQuery,
NativeSQLQueryReturn[] queryReturns,
Collection additionalQuerySpaces,
SessionFactoryImplementor factory)
|
|
| Uses of HibernateException in org.hibernate.loader.entity |
|---|
| Methods in org.hibernate.loader.entity that throw HibernateException | |
|---|---|
protected Object |
AbstractEntityLoader.getResultColumnOrRow(Object[] row,
ResultTransformer transformer,
ResultSet rs,
SessionImplementor session)
|
protected Object |
CollectionElementLoader.getResultColumnOrRow(Object[] row,
ResultTransformer transformer,
ResultSet rs,
SessionImplementor session)
|
Object |
UniqueEntityLoader.load(Serializable id,
Object optionalObject,
SessionImplementor session)
Deprecated. use UniqueEntityLoader.load(java.io.Serializable, Object, SessionImplementor, LockOptions) instead. |
Object |
CollectionElementLoader.loadElement(SessionImplementor session,
Object key,
Object index)
|
| Uses of HibernateException in org.hibernate.loader.hql |
|---|
| Methods in org.hibernate.loader.hql that throw HibernateException | |
|---|---|
protected Object |
QueryLoader.getResultColumnOrRow(Object[] row,
ResultTransformer transformer,
ResultSet rs,
SessionImplementor session)
|
protected Object[] |
QueryLoader.getResultRow(Object[] row,
ResultSet rs,
SessionImplementor session)
|
Iterator |
QueryLoader.iterate(QueryParameters queryParameters,
EventSource session)
|
List |
QueryLoader.list(SessionImplementor session,
QueryParameters queryParameters)
|
ScrollableResults |
QueryLoader.scroll(QueryParameters queryParameters,
SessionImplementor session)
|
void |
QueryLoader.validateScrollability()
|
| Uses of HibernateException in org.hibernate.mapping |
|---|
| Methods in org.hibernate.mapping that throw HibernateException | |
|---|---|
String |
Column.getSqlType(Dialect dialect,
Mapping mapping)
|
Iterator |
Table.sqlAlterStrings(Dialect dialect,
Mapping p,
TableMetadata tableInfo,
String defaultCatalog,
String defaultSchema)
|
String |
RelationalModel.sqlCreateString(Dialect dialect,
Mapping p,
String defaultCatalog,
String defaultSchema)
|
String |
SimpleAuxiliaryDatabaseObject.sqlCreateString(Dialect dialect,
Mapping p,
String defaultCatalog,
String defaultSchema)
|
String |
Index.sqlCreateString(Dialect dialect,
Mapping mapping,
String defaultCatalog,
String defaultSchema)
|
String |
Table.sqlTemporaryTableCreateString(Dialect dialect,
Mapping mapping)
|
| Uses of HibernateException in org.hibernate.metadata |
|---|
| Methods in org.hibernate.metadata that throw HibernateException | |
|---|---|
Serializable |
ClassMetadata.getIdentifier(Object object)
Deprecated. Use ClassMetadata.getIdentifier(Object,SessionImplementor) instead |
Type |
ClassMetadata.getPropertyType(String propertyName)
Get the type of a particular (named) property |
Object |
ClassMetadata.getPropertyValue(Object object,
String propertyName)
Get the value of a particular (named) property |
Object[] |
ClassMetadata.getPropertyValues(Object entity)
Extract the property values from the given entity. |
Object[] |
ClassMetadata.getPropertyValuesToInsert(Object entity,
Map mergeMap,
SessionImplementor session)
Return the values of the mapped properties of the object |
Object |
ClassMetadata.getVersion(Object object)
Get the version number (or timestamp) from the object's version property (or return null if not versioned) |
void |
ClassMetadata.setPropertyValue(Object object,
String propertyName,
Object value)
Set the value of a particular (named) property |
void |
ClassMetadata.setPropertyValues(Object object,
Object[] values)
Set the given values to the mapped properties of the given object |
| Uses of HibernateException in org.hibernate.metamodel |
|---|
| Subclasses of HibernateException in org.hibernate.metamodel | |
|---|---|
class |
ValidationException
Indicates a problem validating the metamodel. |
| Uses of HibernateException in org.hibernate.metamodel.relational |
|---|
| Subclasses of HibernateException in org.hibernate.metamodel.relational | |
|---|---|
class |
IllegalIdentifierException
Indicates an attempted use of a name that was deemed illegal |
| Uses of HibernateException in org.hibernate.metamodel.source |
|---|
| Subclasses of HibernateException in org.hibernate.metamodel.source | |
|---|---|
class |
XsdException
Indicates an issue finding or loading an XSD schema. |
| Uses of HibernateException in org.hibernate.metamodel.source.annotations |
|---|
| Subclasses of HibernateException in org.hibernate.metamodel.source.annotations | |
|---|---|
class |
UnknownInheritanceTypeException
|
| Uses of HibernateException in org.hibernate.persister.collection |
|---|
| Methods in org.hibernate.persister.collection that throw HibernateException | |
|---|---|
void |
AbstractCollectionPersister.deleteRows(PersistentCollection collection,
Serializable id,
SessionImplementor session)
|
void |
CollectionPersister.deleteRows(PersistentCollection collection,
Serializable key,
SessionImplementor session)
Delete the persistent state of any elements that were removed from the collection |
protected abstract int |
AbstractCollectionPersister.doUpdateRows(Serializable key,
PersistentCollection collection,
SessionImplementor session)
|
protected int |
BasicCollectionPersister.doUpdateRows(Serializable id,
PersistentCollection collection,
SessionImplementor session)
|
void |
AbstractCollectionPersister.initialize(Serializable key,
SessionImplementor session)
|
void |
CollectionPersister.initialize(Serializable key,
SessionImplementor session)
Initialize the given collection with the given key |
void |
NamedQueryCollectionInitializer.initialize(Serializable key,
SessionImplementor session)
|
void |
AbstractCollectionPersister.insertRows(PersistentCollection collection,
Serializable id,
SessionImplementor session)
|
void |
CollectionPersister.insertRows(PersistentCollection collection,
Serializable key,
SessionImplementor session)
Insert the persistent state of any new collection elements |
Object |
AbstractCollectionPersister.readElement(ResultSet rs,
Object owner,
String[] aliases,
SessionImplementor session)
|
Object |
CollectionPersister.readElement(ResultSet rs,
Object owner,
String[] columnAliases,
SessionImplementor session)
Read the element from a row of the JDBC ResultSet |
Object |
AbstractCollectionPersister.readIdentifier(ResultSet rs,
String alias,
SessionImplementor session)
|
Object |
CollectionPersister.readIdentifier(ResultSet rs,
String columnAlias,
SessionImplementor session)
Read the identifier from a row of the JDBC ResultSet |
Object |
AbstractCollectionPersister.readIndex(ResultSet rs,
String[] aliases,
SessionImplementor session)
|
Object |
CollectionPersister.readIndex(ResultSet rs,
String[] columnAliases,
SessionImplementor session)
Read the index from a row of the JDBC ResultSet |
Object |
AbstractCollectionPersister.readKey(ResultSet rs,
String[] aliases,
SessionImplementor session)
|
Object |
CollectionPersister.readKey(ResultSet rs,
String[] keyAliases,
SessionImplementor session)
Read the key from a row of the JDBC ResultSet |
void |
AbstractCollectionPersister.recreate(PersistentCollection collection,
Serializable id,
SessionImplementor session)
|
void |
CollectionPersister.recreate(PersistentCollection collection,
Serializable key,
SessionImplementor session)
(Re)create the collection's persistent state |
void |
AbstractCollectionPersister.remove(Serializable id,
SessionImplementor session)
|
void |
CollectionPersister.remove(Serializable id,
SessionImplementor session)
Completely remove the persistent state of the collection |
void |
AbstractCollectionPersister.updateRows(PersistentCollection collection,
Serializable id,
SessionImplementor session)
|
void |
CollectionPersister.updateRows(PersistentCollection collection,
Serializable key,
SessionImplementor session)
Update the persistent state of any elements that were modified |
protected int |
AbstractCollectionPersister.writeElement(PreparedStatement st,
Object elt,
int i,
SessionImplementor session)
Write the element to a JDBC PreparedStatement |
protected int |
AbstractCollectionPersister.writeElementToWhere(PreparedStatement st,
Object elt,
int i,
SessionImplementor session)
Write the element to a JDBC PreparedStatement |
int |
AbstractCollectionPersister.writeIdentifier(PreparedStatement st,
Object id,
int i,
SessionImplementor session)
Write the identifier to a JDBC PreparedStatement |
protected int |
AbstractCollectionPersister.writeIndex(PreparedStatement st,
Object index,
int i,
SessionImplementor session)
Write the index to a JDBC PreparedStatement |
protected int |
AbstractCollectionPersister.writeIndexToWhere(PreparedStatement st,
Object index,
int i,
SessionImplementor session)
Write the index to a JDBC PreparedStatement |
protected int |
AbstractCollectionPersister.writeKey(PreparedStatement st,
Serializable key,
int i,
SessionImplementor session)
Write the key to a JDBC PreparedStatement |
| Uses of HibernateException in org.hibernate.persister.entity |
|---|
| Methods in org.hibernate.persister.entity that throw HibernateException | |
|---|---|
protected boolean |
AbstractEntityPersister.check(int rows,
Serializable id,
int tableNumber,
Expectation expectation,
PreparedStatement statement)
|
Object |
EntityPersister.createProxy(Serializable id,
SessionImplementor session)
Create a new proxy instance |
Object |
AbstractEntityPersister.createProxy(Serializable id,
SessionImplementor session)
|
Object |
DiscriminatorType.deepCopy(Object value,
SessionFactoryImplementor factory)
|
protected int |
AbstractEntityPersister.dehydrate(Serializable id,
Object[] fields,
boolean[] includeProperty,
boolean[][] includeColumns,
int j,
PreparedStatement st,
SessionImplementor session)
|
protected int |
AbstractEntityPersister.dehydrate(Serializable id,
Object[] fields,
Object rowId,
boolean[] includeProperty,
boolean[][] includeColumns,
int j,
PreparedStatement ps,
SessionImplementor session,
int index)
Marshall the fields of a persistent instance to a prepared statement |
protected void |
AbstractEntityPersister.delete(Serializable id,
Object version,
int j,
Object object,
String sql,
SessionImplementor session,
Object[] loadedState)
Perform an SQL DELETE |
void |
EntityPersister.delete(Serializable id,
Object version,
Object object,
SessionImplementor session)
Delete a persistent instance |
void |
AbstractEntityPersister.delete(Serializable id,
Object version,
Object object,
SessionImplementor session)
Delete an object |
int[] |
AbstractEntityPersister.findDirty(Object[] currentState,
Object[] previousState,
Object entity,
SessionImplementor session)
Locate the property-indices of all properties considered to be dirty. |
int[] |
AbstractEntityPersister.findModified(Object[] old,
Object[] current,
Object entity,
SessionImplementor session)
Locate the property-indices of all properties considered to be dirty. |
Object |
EntityPersister.forceVersionIncrement(Serializable id,
Object currentVersion,
SessionImplementor session)
|
Object |
DiscriminatorType.fromXMLNode(org.dom4j.Node xml,
Mapping factory)
|
Object |
EntityPersister.getCurrentVersion(Serializable id,
SessionImplementor session)
Get the current version of the object, or return null if there is no row for the given identifier. |
Object |
AbstractEntityPersister.getCurrentVersion(Serializable id,
SessionImplementor session)
Retrieve the version number |
Object[] |
EntityPersister.getDatabaseSnapshot(Serializable id,
SessionImplementor session)
Get the current database state of the object, in a "hydrated" form, without resolving identifiers |
Object[] |
AbstractEntityPersister.getDatabaseSnapshot(Serializable id,
SessionImplementor session)
|
Serializable |
EntityPersister.getIdentifier(Object object)
Deprecated. Use EntityPersister.getIdentifier(Object,SessionImplementor) instead |
IdentifierGenerator |
AbstractEntityPersister.getIdentifierGenerator()
|
Object[] |
AbstractEntityPersister.getNaturalIdentifierSnapshot(Serializable id,
SessionImplementor session)
|
Object |
EntityPersister.getPropertyValue(Object object,
int i)
Get the value of a particular property |
Object[] |
EntityPersister.getPropertyValuesToInsert(Object object,
Map mergeMap,
SessionImplementor session)
Return the values of the insertable properties of the object (including backrefs) |
Object[] |
AbstractEntityPersister.getPropertyValuesToInsert(Object object,
Map mergeMap,
SessionImplementor session)
|
Object |
EntityPersister.getVersion(Object object)
Get the version number (or timestamp) from the object's version property (or return null if not versioned) |
Object[] |
AbstractEntityPersister.hydrate(ResultSet rs,
Serializable id,
Object object,
Loadable rootLoadable,
String[][] suffixedPropertyColumns,
boolean allProperties,
SessionImplementor session)
Unmarshall the fields of a persistent instance from a result set, without resolving associations or collections. |
Object[] |
Loadable.hydrate(ResultSet rs,
Serializable id,
Object object,
Loadable rootLoadable,
String[][] suffixedPropertyColumns,
boolean allProperties,
SessionImplementor session)
Retrieve property values from one row of a result set |
Object |
AbstractEntityPersister.initializeLazyProperty(String fieldName,
Object entity,
SessionImplementor session)
|
protected Serializable |
AbstractEntityPersister.insert(Object[] fields,
boolean[] notNull,
String sql,
Object object,
SessionImplementor session)
Perform an SQL INSERT, and then retrieve a generated identifier. |
Serializable |
EntityPersister.insert(Object[] fields,
Object object,
SessionImplementor session)
Persist an instance, using a natively generated identifier (optional operation) |
Serializable |
AbstractEntityPersister.insert(Object[] fields,
Object object,
SessionImplementor session)
|
protected void |
AbstractEntityPersister.insert(Serializable id,
Object[] fields,
boolean[] notNull,
int j,
String sql,
Object object,
SessionImplementor session)
Perform an SQL INSERT. |
void |
EntityPersister.insert(Serializable id,
Object[] fields,
Object object,
SessionImplementor session)
Persist an instance |
void |
AbstractEntityPersister.insert(Serializable id,
Object[] fields,
Object object,
SessionImplementor session)
|
boolean |
DiscriminatorType.isDirty(Object old,
Object current,
boolean[] checkable,
SessionImplementor session)
|
Boolean |
EntityPersister.isTransient(Object object,
SessionImplementor session)
Is this a new transient instance? |
Boolean |
AbstractEntityPersister.isTransient(Object entity,
SessionImplementor session)
|
Object |
EntityPersister.load(Serializable id,
Object optionalObject,
LockMode lockMode,
SessionImplementor session)
Load an instance of the persistent class. |
Object |
EntityPersister.load(Serializable id,
Object optionalObject,
LockOptions lockOptions,
SessionImplementor session)
Load an instance of the persistent class. |
Object |
AbstractEntityPersister.load(Serializable id,
Object optionalObject,
LockOptions lockOptions,
SessionImplementor session)
Load an instance using either the forUpdateLoader or the outer joining loader, depending upon the value of the lock parameter |
Object |
UniqueKeyLoadable.loadByUniqueKey(String propertyName,
Object uniqueKey,
SessionImplementor session)
Load an instance of the persistent class, by a unique key other than the primary key. |
Object |
AbstractEntityPersister.loadByUniqueKey(String propertyName,
Object uniqueKey,
SessionImplementor session)
|
void |
EntityPersister.lock(Serializable id,
Object version,
Object object,
LockMode lockMode,
SessionImplementor session)
Do a version check (optional operation) |
void |
AbstractEntityPersister.lock(Serializable id,
Object version,
Object object,
LockMode lockMode,
SessionImplementor session)
|
void |
EntityPersister.lock(Serializable id,
Object version,
Object object,
LockOptions lockOptions,
SessionImplementor session)
Do a version check (optional operation) |
void |
AbstractEntityPersister.lock(Serializable id,
Object version,
Object object,
LockOptions lockOptions,
SessionImplementor session)
|
Object |
DiscriminatorType.nullSafeGet(ResultSet rs,
String[] names,
SessionImplementor session,
Object owner)
|
Object |
DiscriminatorType.nullSafeGet(ResultSet rs,
String name,
SessionImplementor session,
Object owner)
|
void |
DiscriminatorType.nullSafeSet(PreparedStatement st,
Object value,
int index,
boolean[] settable,
SessionImplementor session)
|
void |
DiscriminatorType.nullSafeSet(PreparedStatement st,
Object value,
int index,
SessionImplementor session)
|
Object |
DiscriminatorType.replace(Object original,
Object target,
SessionImplementor session,
Object owner,
Map copyCache)
|
void |
DiscriminatorType.setToXMLNode(org.dom4j.Node node,
Object value,
SessionFactoryImplementor factory)
|
String |
DiscriminatorType.toLoggableString(Object value,
SessionFactoryImplementor factory)
|
void |
EntityPersister.update(Serializable id,
Object[] fields,
int[] dirtyFields,
boolean hasDirtyCollection,
Object[] oldFields,
Object oldVersion,
Object object,
Object rowId,
SessionImplementor session)
Update a persistent instance |
void |
AbstractEntityPersister.update(Serializable id,
Object[] fields,
int[] dirtyFields,
boolean hasDirtyCollection,
Object[] oldFields,
Object oldVersion,
Object object,
Object rowId,
SessionImplementor session)
Update an object |
protected boolean |
AbstractEntityPersister.update(Serializable id,
Object[] fields,
Object[] oldFields,
Object rowId,
boolean[] includeProperty,
int j,
Object oldVersion,
Object object,
String sql,
SessionImplementor session)
|
protected void |
AbstractEntityPersister.updateOrInsert(Serializable id,
Object[] fields,
Object[] oldFields,
Object rowId,
boolean[] includeProperty,
int j,
Object oldVersion,
Object object,
String sql,
SessionImplementor session)
Perform an SQL UPDATE or SQL INSERT |
| Uses of HibernateException in org.hibernate.persister.internal |
|---|
| Methods in org.hibernate.persister.internal that throw HibernateException | |
|---|---|
CollectionPersister |
PersisterFactoryImpl.createCollectionPersister(Configuration cfg,
Collection collectionMetadata,
CollectionRegionAccessStrategy cacheAccessStrategy,
SessionFactoryImplementor factory)
|
CollectionPersister |
PersisterFactoryImpl.createCollectionPersister(MetadataImplementor metadata,
PluralAttributeBinding collectionMetadata,
CollectionRegionAccessStrategy cacheAccessStrategy,
SessionFactoryImplementor factory)
|
| Uses of HibernateException in org.hibernate.persister.spi |
|---|
| Subclasses of HibernateException in org.hibernate.persister.spi | |
|---|---|
class |
UnknownPersisterException
Indicates that the persister to use is not known and couyld not be determined. |
| Uses of HibernateException in org.hibernate.property |
|---|
| Methods in org.hibernate.property that throw HibernateException | |
|---|---|
Object |
EmbeddedPropertyAccessor.EmbeddedGetter.get(Object target)
Get the property value from the given instance . |
Object |
Getter.get(Object owner)
Get the property value from the given instance . |
Object |
BasicPropertyAccessor.BasicGetter.get(Object target)
Get the property value from the given instance . |
Object |
DirectPropertyAccessor.DirectGetter.get(Object target)
Get the property value from the given instance . |
Object |
MapAccessor.MapGetter.get(Object target)
Get the property value from the given instance . |
Object |
Getter.getForInsert(Object owner,
Map mergeMap,
SessionImplementor session)
Get the property value from the given owner instance. |
Object |
IndexPropertyAccessor.IndexGetter.getForInsert(Object target,
Map mergeMap,
SessionImplementor session)
|
void |
Setter.set(Object target,
Object value,
SessionFactoryImplementor factory)
Set the property value from the given instance |
void |
BasicPropertyAccessor.BasicSetter.set(Object target,
Object value,
SessionFactoryImplementor factory)
|
void |
DirectPropertyAccessor.DirectSetter.set(Object target,
Object value,
SessionFactoryImplementor factory)
Set the property value from the given instance |
void |
MapAccessor.MapSetter.set(Object target,
Object value,
SessionFactoryImplementor factory)
Set the property value from the given instance |
| Uses of HibernateException in org.hibernate.proxy |
|---|
| Methods in org.hibernate.proxy that throw HibernateException | |
|---|---|
Object |
AbstractLazyInitializer.getImplementation(SessionImplementor s)
|
Object |
LazyInitializer.getImplementation(SessionImplementor session)
Return the underlying persistent object in the given session, or null if not contained in this session's persistence context. |
HibernateProxy |
ProxyFactory.getProxy(Serializable id,
SessionImplementor session)
Create a new proxy instance |
void |
AbstractLazyInitializer.initialize()
|
void |
LazyInitializer.initialize()
Initialize the proxy, fetching the target entity if necessary. |
void |
ProxyFactory.postInstantiate(String entityName,
Class persistentClass,
Set interfaces,
Method getIdentifierMethod,
Method setIdentifierMethod,
CompositeType componentIdType)
Called immediately after instantiation of this factory. |
void |
AbstractLazyInitializer.setSession(SessionImplementor s)
|
void |
LazyInitializer.setSession(SessionImplementor session)
Associate the proxy with the given session. |
| Uses of HibernateException in org.hibernate.proxy.dom4j |
|---|
| Methods in org.hibernate.proxy.dom4j that throw HibernateException | |
|---|---|
HibernateProxy |
Dom4jProxyFactory.getProxy(Serializable id,
SessionImplementor session)
Create a new proxy |
void |
Dom4jProxyFactory.postInstantiate(String entityName,
Class persistentClass,
Set interfaces,
Method getIdentifierMethod,
Method setIdentifierMethod,
CompositeType componentIdType)
Called immediately after instantiation |
| Uses of HibernateException in org.hibernate.proxy.map |
|---|
| Methods in org.hibernate.proxy.map that throw HibernateException | |
|---|---|
HibernateProxy |
MapProxyFactory.getProxy(Serializable id,
SessionImplementor session)
|
void |
MapProxyFactory.postInstantiate(String entityName,
Class persistentClass,
Set interfaces,
Method getIdentifierMethod,
Method setIdentifierMethod,
CompositeType componentIdType)
|
| Uses of HibernateException in org.hibernate.proxy.pojo.javassist |
|---|
| Methods in org.hibernate.proxy.pojo.javassist that throw HibernateException | |
|---|---|
static HibernateProxy |
JavassistLazyInitializer.getProxy(Class factory,
String entityName,
Class persistentClass,
Class[] interfaces,
Method getIdentifierMethod,
Method setIdentifierMethod,
CompositeType componentIdType,
Serializable id,
SessionImplementor session,
boolean classOverridesEquals)
|
HibernateProxy |
JavassistProxyFactory.getProxy(Serializable id,
SessionImplementor session)
|
static HibernateProxy |
JavassistLazyInitializer.getProxy(String entityName,
Class persistentClass,
Class[] interfaces,
Method getIdentifierMethod,
Method setIdentifierMethod,
CompositeType componentIdType,
Serializable id,
SessionImplementor session)
|
static Class |
JavassistLazyInitializer.getProxyFactory(Class persistentClass,
Class[] interfaces)
|
void |
JavassistProxyFactory.postInstantiate(String entityName,
Class persistentClass,
Set interfaces,
Method getIdentifierMethod,
Method setIdentifierMethod,
CompositeType componentIdType)
|
| Uses of HibernateException in org.hibernate.secure.internal |
|---|
| Constructors in org.hibernate.secure.internal that throw HibernateException | |
|---|---|
JACCConfiguration(String contextId)
|
|
| Uses of HibernateException in org.hibernate.service |
|---|
| Subclasses of HibernateException in org.hibernate.service | |
|---|---|
class |
UnknownServiceException
Indicates that an unkown service was requested from the registry. |
class |
UnknownUnwrapTypeException
|
| Uses of HibernateException in org.hibernate.service.classloading.spi |
|---|
| Subclasses of HibernateException in org.hibernate.service.classloading.spi | |
|---|---|
class |
ClassLoadingException
Indicates a problem performing class loading |
| Uses of HibernateException in org.hibernate.service.internal |
|---|
| Subclasses of HibernateException in org.hibernate.service.internal | |
|---|---|
class |
ServiceDependencyException
Indictes a problem processing service dependencies. |
class |
ServiceProxyGenerationException
Indicates a problem generating a service proxy |
| Uses of HibernateException in org.hibernate.service.jdbc.connections.internal |
|---|
| Methods in org.hibernate.service.jdbc.connections.internal that throw HibernateException | |
|---|---|
void |
ProxoolConnectionProvider.close()
Release all resources held by this provider. |
void |
ProxoolConnectionProvider.configure(Properties props)
Initialize the connection provider from given properties. |
| Uses of HibernateException in org.hibernate.service.jdbc.dialect.internal |
|---|
| Methods in org.hibernate.service.jdbc.dialect.internal that throw HibernateException | |
|---|---|
Dialect |
DialectFactoryImpl.buildDialect(Map configValues,
Connection connection)
|
| Uses of HibernateException in org.hibernate.service.jdbc.dialect.spi |
|---|
| Methods in org.hibernate.service.jdbc.dialect.spi that throw HibernateException | |
|---|---|
Dialect |
DialectFactory.buildDialect(Map configValues,
Connection connection)
Builds an appropriate Dialect instance. |
| Uses of HibernateException in org.hibernate.service.jndi |
|---|
| Subclasses of HibernateException in org.hibernate.service.jndi | |
|---|---|
class |
JndiException
An exception indicating trouble accessing JNDI |
class |
JndiNameException
Indicates a problem with a given JNDI name being deemed as not valid. |
| Uses of HibernateException in org.hibernate.service.jta.platform.spi |
|---|
| Subclasses of HibernateException in org.hibernate.service.jta.platform.spi | |
|---|---|
class |
JtaPlatformException
Indicates a problem interacting with the underlying JTA platform. |
| Uses of HibernateException in org.hibernate.service.spi |
|---|
| Subclasses of HibernateException in org.hibernate.service.spi | |
|---|---|
class |
ServiceException
Indicates a problem with a service. |
| Uses of HibernateException in org.hibernate.sql.ordering.antlr |
|---|
| Methods in org.hibernate.sql.ordering.antlr that throw HibernateException | |
|---|---|
String[] |
ColumnMapper.map(String reference)
Resolve the property reference to its underlying columns. |
| Uses of HibernateException in org.hibernate.testing.junit4 |
|---|
| Methods in org.hibernate.testing.junit4 that throw HibernateException | |
|---|---|
protected Session |
BaseCoreFunctionalTestCase.openSession()
|
protected Session |
BaseCoreFunctionalTestCase.openSession(Interceptor interceptor)
|
| Uses of HibernateException in org.hibernate.tool |
|---|
| Constructors in org.hibernate.tool that throw HibernateException | |
|---|---|
EnversSchemaGenerator(Configuration configuration,
Connection connection)
|
|
EnversSchemaGenerator(Configuration configuration,
Properties properties)
|
|
| Uses of HibernateException in org.hibernate.tool.hbm2ddl |
|---|
| Subclasses of HibernateException in org.hibernate.tool.hbm2ddl | |
|---|---|
class |
ImportScriptException
|
| Methods in org.hibernate.tool.hbm2ddl that throw HibernateException | |
|---|---|
TableMetadata |
DatabaseMetadata.getTableMetadata(String name,
String schema,
String catalog,
boolean isQuoted)
|
boolean |
DatabaseMetadata.isTable(Object key)
|
| Constructors in org.hibernate.tool.hbm2ddl that throw HibernateException | |
|---|---|
SchemaExport(Configuration configuration,
Connection connection)
Create a schema exporter for the given Configuration, using the supplied connection for connectivity. |
|
SchemaExport(Configuration configuration,
Properties properties)
Deprecated. properties may be specified via the Configuration object |
|
SchemaUpdate(Configuration cfg)
|
|
SchemaUpdate(Configuration configuration,
Properties properties)
|
|
SchemaUpdate(ServiceRegistry serviceRegistry,
Configuration cfg)
|
|
SchemaValidator(Configuration cfg)
|
|
SchemaValidator(Configuration cfg,
Properties connectionProperties)
|
|
SchemaValidator(ServiceRegistry serviceRegistry,
Configuration cfg)
|
|
| Uses of HibernateException in org.hibernate.transaction |
|---|
| Methods in org.hibernate.transaction that throw HibernateException | |
|---|---|
TransactionManager |
TransactionManagerLookup.getTransactionManager(Properties props)
Obtain the JTA TransactionManager. |
| Uses of HibernateException in org.hibernate.tuple.component |
|---|
| Methods in org.hibernate.tuple.component that throw HibernateException | |
|---|---|
Object |
AbstractComponentTuplizer.getPropertyValue(Object component,
int i)
|
Object[] |
PojoComponentTuplizer.getPropertyValues(Object component)
|
Object[] |
AbstractComponentTuplizer.getPropertyValues(Object component)
|
Object |
AbstractComponentTuplizer.instantiate()
This method does not populate the component parent |
void |
PojoComponentTuplizer.setPropertyValues(Object component,
Object[] values)
|
void |
AbstractComponentTuplizer.setPropertyValues(Object component,
Object[] values)
|
| Uses of HibernateException in org.hibernate.tuple.entity |
|---|
| Methods in org.hibernate.tuple.entity that throw HibernateException | |
|---|---|
Object |
EntityTuplizer.createProxy(Serializable id,
SessionImplementor session)
Generates an appropriate proxy representation of this entity for this entity-mode. |
Object |
AbstractEntityTuplizer.createProxy(Serializable id,
SessionImplementor session)
|
Serializable |
EntityTuplizer.getIdentifier(Object entity)
Deprecated. Use EntityTuplizer.getIdentifier(Object,SessionImplementor) instead. |
Serializable |
AbstractEntityTuplizer.getIdentifier(Object entity)
|
Object |
AbstractEntityTuplizer.getPropertyValue(Object entity,
int i)
|
Object |
EntityTuplizer.getPropertyValue(Object entity,
String propertyName)
Extract the value of a particular property from the given entity. |
Object |
AbstractEntityTuplizer.getPropertyValue(Object entity,
String propertyPath)
|
Object[] |
AbstractEntityTuplizer.getPropertyValues(Object entity)
|
Object[] |
PojoEntityTuplizer.getPropertyValues(Object entity)
Extract the current values contained on the given entity. |
Object[] |
EntityTuplizer.getPropertyValuesToInsert(Object entity,
Map mergeMap,
SessionImplementor session)
Extract the values of the insertable properties of the entity (including backrefs) |
Object[] |
AbstractEntityTuplizer.getPropertyValuesToInsert(Object entity,
Map mergeMap,
SessionImplementor session)
|
Object[] |
PojoEntityTuplizer.getPropertyValuesToInsert(Object entity,
Map mergeMap,
SessionImplementor session)
Extract the values of the insertable properties of the entity (including backrefs) |
Object |
EntityTuplizer.getVersion(Object entity)
Extract the value of the version property from the given entity. |
Object |
AbstractEntityTuplizer.getVersion(Object entity)
|
Object |
AbstractEntityTuplizer.instantiate()
|
Object |
EntityTuplizer.instantiate(Serializable id)
Deprecated. Use EntityTuplizer.instantiate(Serializable, SessionImplementor) instead. |
Object |
AbstractEntityTuplizer.instantiate(Serializable id)
|
void |
EntityTuplizer.setIdentifier(Object entity,
Serializable id)
Deprecated. Use EntityTuplizer.setIdentifier(Object, Serializable, SessionImplementor) instead. |
void |
AbstractEntityTuplizer.setIdentifier(Object entity,
Serializable id)
Inject the identifier value into the given entity. |
void |
EntityTuplizer.setPropertyValue(Object entity,
int i,
Object value)
Inject the value of a particular property. |
void |
AbstractEntityTuplizer.setPropertyValue(Object entity,
int i,
Object value)
|
void |
EntityTuplizer.setPropertyValue(Object entity,
String propertyName,
Object value)
Inject the value of a particular property. |
void |
AbstractEntityTuplizer.setPropertyValue(Object entity,
String propertyName,
Object value)
|
void |
AbstractEntityTuplizer.setPropertyValues(Object entity,
Object[] values)
|
void |
PojoEntityTuplizer.setPropertyValues(Object entity,
Object[] values)
Inject the given values into the given entity. |
| Uses of HibernateException in org.hibernate.type |
|---|
| Subclasses of HibernateException in org.hibernate.type | |
|---|---|
class |
SerializationException
Thrown when a property cannot be serializaed/deserialized |
| Methods in org.hibernate.type that throw HibernateException | |
|---|---|
Object |
StringClobType.assemble(Serializable cached,
Object owner)
Deprecated. |
Object |
EnumType.assemble(Serializable cached,
Object owner)
|
Object |
CompositeCustomType.assemble(Serializable cached,
SessionImplementor session,
Object owner)
|
Object |
Type.assemble(Serializable cached,
SessionImplementor session,
Object owner)
Reconstruct the object from its disassembled state. |
Object |
ComponentType.assemble(Serializable object,
SessionImplementor session,
Object owner)
|
Object |
SpecialOneToOneType.assemble(Serializable oid,
SessionImplementor session,
Object owner)
|
Object |
ManyToOneType.assemble(Serializable oid,
SessionImplementor session,
Object owner)
|
Object |
OneToOneType.assemble(Serializable oid,
SessionImplementor session,
Object owner)
|
Object |
CollectionType.assemble(Serializable cached,
SessionImplementor session,
Object owner)
|
Object |
AnyType.assemble(Serializable cached,
SessionImplementor session,
Object owner)
|
Object |
CustomType.assemble(Serializable cached,
SessionImplementor session,
Object owner)
|
Object |
AbstractType.assemble(Serializable cached,
SessionImplementor session,
Object owner)
|
Object |
AbstractStandardBasicType.assemble(Serializable cached,
SessionImplementor session,
Object owner)
|
Object |
StringClobType.deepCopy(Object value)
Deprecated. |
Object |
EnumType.deepCopy(Object value)
|
Object |
CompositeCustomType.deepCopy(Object value,
SessionFactoryImplementor factory)
|
Object |
SerializableToBlobType.deepCopy(Object value,
SessionFactoryImplementor factory)
|
Object |
MetaType.deepCopy(Object value,
SessionFactoryImplementor factory)
|
Object |
Type.deepCopy(Object value,
SessionFactoryImplementor factory)
Return a deep copy of the persistent state, stopping at entities and at collections. |
Object |
ComponentType.deepCopy(Object component,
SessionFactoryImplementor factory)
|
Object |
ByteArrayBlobType.deepCopy(Object value,
SessionFactoryImplementor factory)
Deprecated. |
Object |
MutableType.deepCopy(Object value,
SessionFactoryImplementor factory)
Deprecated. |
Object |
CollectionType.deepCopy(Object value,
SessionFactoryImplementor factory)
|
Object |
AnyType.deepCopy(Object value,
SessionFactoryImplementor factory)
|
Object |
CustomType.deepCopy(Object value,
SessionFactoryImplementor factory)
|
protected Object |
AbstractCharArrayType.deepCopyNotNull(Object value)
Deprecated. |
protected abstract Object |
MutableType.deepCopyNotNull(Object value)
Deprecated. |
Serializable |
StringClobType.disassemble(Object value)
Deprecated. |
Serializable |
EnumType.disassemble(Object value)
|
Serializable |
CompositeCustomType.disassemble(Object value,
SessionImplementor session,
Object owner)
|
Serializable |
Type.disassemble(Object value,
SessionImplementor session,
Object owner)
Return a disassembled representation of the object. |
Serializable |
ComponentType.disassemble(Object value,
SessionImplementor session,
Object owner)
|
Serializable |
SpecialOneToOneType.disassemble(Object value,
SessionImplementor session,
Object owner)
|
Serializable |
ManyToOneType.disassemble(Object value,
SessionImplementor session,
Object owner)
|
Serializable |
OneToOneType.disassemble(Object value,
SessionImplementor session,
Object owner)
|
Serializable |
CollectionType.disassemble(Object value,
SessionImplementor session,
Object owner)
|
Serializable |
AnyType.disassemble(Object value,
SessionImplementor session,
Object owner)
|
Serializable |
CustomType.disassemble(Object value,
SessionImplementor session,
Object owner)
|
Serializable |
AbstractType.disassemble(Object value,
SessionImplementor session,
Object owner)
|
Serializable |
AbstractStandardBasicType.disassemble(Object value,
SessionImplementor session,
Object owner)
|
boolean |
StringClobType.equals(Object x,
Object y)
Deprecated. |
boolean |
EnumType.equals(Object x,
Object y)
|
Date |
TimestampType.fromStringValue(String xml)
|
Object |
AbstractBynaryType.fromStringValue(String xml)
Deprecated. |
T |
SingleColumnType.fromStringValue(String xml)
|
T |
StringRepresentableType.fromStringValue(String string)
Consume the given string representation back into this types java form. |
abstract Object |
NullableType.fromStringValue(String xml)
Deprecated. |
T |
AbstractStandardBasicType.fromStringValue(String xml)
|
Object |
CompositeCustomType.fromXMLNode(org.dom4j.Node xml,
Mapping factory)
|
Object |
SerializableToBlobType.fromXMLNode(org.dom4j.Node xml,
Mapping factory)
|
Object |
MetaType.fromXMLNode(org.dom4j.Node xml,
Mapping factory)
|
Object |
Type.fromXMLNode(org.dom4j.Node xml,
Mapping factory)
Parse the XML representation of an instance. |
Object |
ComponentType.fromXMLNode(org.dom4j.Node xml,
Mapping factory)
|
Object |
ByteArrayBlobType.fromXMLNode(org.dom4j.Node xml,
Mapping factory)
Deprecated. |
Object |
CollectionType.fromXMLNode(org.dom4j.Node xml,
Mapping factory)
|
Object |
AnyType.fromXMLNode(org.dom4j.Node xml,
Mapping factory)
|
Object |
CustomType.fromXMLNode(org.dom4j.Node xml,
Mapping factory)
|
Object |
EntityType.fromXMLNode(org.dom4j.Node xml,
Mapping factory)
Parse the XML representation of an instance. |
Object |
NullableType.fromXMLNode(org.dom4j.Node xml,
Mapping factory)
Deprecated. |
Object |
MetaType.fromXMLString(String xml,
Mapping factory)
|
Object |
NullableType.fromXMLString(String xml,
Mapping factory)
Deprecated. |
T |
XmlRepresentableType.fromXMLString(String xml,
Mapping factory)
|
T |
AbstractStandardBasicType.fromXMLString(String xml,
Mapping factory)
|
Object |
AbstractLongStringType.get(ResultSet rs,
String name)
Deprecated. |
Object |
AbstractBynaryType.get(ResultSet rs,
String name)
Deprecated. |
abstract Object |
NullableType.get(ResultSet rs,
String name)
Deprecated. Get a column value from a result set, without worrying about the possibility of null values. |
Object |
SingleColumnType.get(ResultSet rs,
String name,
SessionImplementor session)
Get a column value from a result set, without worrying about the possibility of null values. |
Object |
AbstractStandardBasicType.get(ResultSet rs,
String name,
SessionImplementor session)
|
int |
Type.getHashCode(Object x)
Get a hash code, consistent with persistence "equality". |
int |
Type.getHashCode(Object x,
SessionFactoryImplementor factory)
Get a hash code, consistent with persistence "equality". |
protected Object |
EntityType.getIdentifier(Object value,
SessionImplementor session)
|
Object |
CompositeCustomType.getPropertyValue(Object component,
int i)
|
Object |
ComponentType.getPropertyValue(Object component,
int i,
EntityMode entityMode)
|
Object |
CompositeCustomType.getPropertyValue(Object component,
int i,
SessionImplementor session)
|
Object |
ComponentType.getPropertyValue(Object component,
int i,
SessionImplementor session)
|
Object |
CompositeType.getPropertyValue(Object component,
int index,
SessionImplementor session)
Extract a particular component property value indicated by index. |
Object |
AnyType.getPropertyValue(Object component,
int i,
SessionImplementor session)
|
Object[] |
CompositeCustomType.getPropertyValues(Object component,
EntityMode entityMode)
|
Object[] |
ComponentType.getPropertyValues(Object component,
EntityMode entityMode)
|
Object[] |
CompositeType.getPropertyValues(Object component,
EntityMode entityMode)
Extract the values of the component properties from the given component instance without access to the session. |
Object[] |
CompositeCustomType.getPropertyValues(Object component,
SessionImplementor session)
|
Object[] |
ComponentType.getPropertyValues(Object component,
SessionImplementor session)
|
Object[] |
CompositeType.getPropertyValues(Object component,
SessionImplementor session)
Extract the values of the component properties from the given component instance |
Object[] |
AnyType.getPropertyValues(Object component,
SessionImplementor session)
|
int |
StringClobType.hashCode(Object x)
Deprecated. |
int |
EnumType.hashCode(Object x)
|
Object |
Type.hydrate(ResultSet rs,
String[] names,
SessionImplementor session,
Object owner)
Extract a value from the JDBC result set. |
Object |
ComponentType.hydrate(ResultSet rs,
String[] names,
SessionImplementor session,
Object owner)
|
Object |
SpecialOneToOneType.hydrate(ResultSet rs,
String[] names,
SessionImplementor session,
Object owner)
|
Object |
ManyToOneType.hydrate(ResultSet rs,
String[] names,
SessionImplementor session,
Object owner)
|
Object |
OneToOneType.hydrate(ResultSet rs,
String[] names,
SessionImplementor session,
Object owner)
|
Object |
AnyType.hydrate(ResultSet rs,
String[] names,
SessionImplementor session,
Object owner)
|
Object |
AbstractType.hydrate(ResultSet rs,
String[] names,
SessionImplementor session,
Object owner)
|
Object |
AbstractStandardBasicType.hydrate(ResultSet rs,
String[] names,
SessionImplementor session,
Object owner)
|
Object |
ComponentType.instantiate(EntityMode entityMode)
This method does not populate the component parent |
Object |
ComponentType.instantiate(Object parent,
SessionImplementor session)
|
Object |
EmbeddedComponentType.instantiate(Object parent,
SessionImplementor session)
|
PersistentCollection |
ArrayType.instantiate(SessionImplementor session,
CollectionPersister persister,
Serializable key)
|
PersistentCollection |
BagType.instantiate(SessionImplementor session,
CollectionPersister persister,
Serializable key)
|
PersistentCollection |
IdentifierBagType.instantiate(SessionImplementor session,
CollectionPersister persister,
Serializable key)
|
PersistentCollection |
CustomCollectionType.instantiate(SessionImplementor session,
CollectionPersister persister,
Serializable key)
|
boolean |
CompositeCustomType.isDirty(Object old,
Object current,
boolean[] checkable,
SessionImplementor session)
|
boolean |
MetaType.isDirty(Object old,
Object current,
boolean[] checkable,
SessionImplementor session)
|
boolean |
Type.isDirty(Object oldState,
Object currentState,
boolean[] checkable,
SessionImplementor session)
Should the parent be considered dirty, given both the old and current value? |
boolean |
ComponentType.isDirty(Object x,
Object y,
boolean[] checkable,
SessionImplementor session)
|
boolean |
AbstractLobType.isDirty(Object old,
Object current,
boolean[] checkable,
SessionImplementor session)
Deprecated. |
boolean |
ManyToOneType.isDirty(Object old,
Object current,
boolean[] checkable,
SessionImplementor session)
|
boolean |
CollectionType.isDirty(Object old,
Object current,
boolean[] checkable,
SessionImplementor session)
|
boolean |
AnyType.isDirty(Object old,
Object current,
boolean[] checkable,
SessionImplementor session)
|
boolean |
CustomType.isDirty(Object old,
Object current,
boolean[] checkable,
SessionImplementor session)
|
boolean |
NullableType.isDirty(Object old,
Object current,
boolean[] checkable,
SessionImplementor session)
Deprecated. |
boolean |
Type.isDirty(Object old,
Object current,
SessionImplementor session)
Should the parent be considered dirty, given both the old and current value? |
boolean |
ComponentType.isDirty(Object x,
Object y,
SessionImplementor session)
|
boolean |
ManyToOneType.isDirty(Object old,
Object current,
SessionImplementor session)
|
boolean |
CollectionType.isDirty(Object old,
Object current,
SessionImplementor session)
|
boolean |
AbstractType.isDirty(Object old,
Object current,
SessionImplementor session)
|
boolean |
CompositeCustomType.isEqual(Object x,
Object y)
|
boolean |
Type.isEqual(Object x,
Object y)
Compare two instances of the class mapped by this type for persistence "equality" (equality of persistent state). |
boolean |
ComponentType.isEqual(Object x,
Object y)
|
boolean |
CustomType.isEqual(Object x,
Object y)
|
boolean |
Type.isEqual(Object x,
Object y,
SessionFactoryImplementor factory)
Compare two instances of the class mapped by this type for persistence "equality" (equality of persistent state). |
boolean |
ComponentType.isEqual(Object x,
Object y,
SessionFactoryImplementor factory)
|
boolean |
Type.isModified(Object dbState,
Object currentState,
boolean[] checkable,
SessionImplementor session)
Has the value been modified compared to the current database state? The difference between this and the Type.isDirty(java.lang.Object, java.lang.Object, org.hibernate.engine.spi.SessionImplementor) methods is that here we need to account for "partially" built values. |
boolean |
ComponentType.isModified(Object old,
Object current,
boolean[] checkable,
SessionImplementor session)
|
boolean |
ManyToOneType.isModified(Object old,
Object current,
boolean[] checkable,
SessionImplementor session)
|
boolean |
CollectionType.isModified(Object old,
Object current,
boolean[] checkable,
SessionImplementor session)
|
boolean |
AnyType.isModified(Object old,
Object current,
boolean[] checkable,
SessionImplementor session)
|
boolean |
AbstractType.isModified(Object old,
Object current,
boolean[] checkable,
SessionImplementor session)
|
boolean |
Type.isSame(Object x,
Object y)
Compare two instances of the class mapped by this type for persistence "equality" (equality of persistent state) taking a shortcut for entity references. |
boolean |
ComponentType.isSame(Object x,
Object y)
|
boolean |
AnyType.isSame(Object x,
Object y)
|
boolean |
AbstractType.isSame(Object x,
Object y)
|
Object |
EntityType.loadByUniqueKey(String entityName,
String uniqueKeyPropertyName,
Object key,
SessionImplementor session)
Load an instance by a unique key that is not the primary key. |
Object |
NullableType.nullSafeGet(ResultSet rs,
String name)
Deprecated. |
Object |
NullableType.nullSafeGet(ResultSet rs,
String[] names)
Deprecated. |
Object |
CompositeCustomType.nullSafeGet(ResultSet rs,
String[] names,
SessionImplementor session,
Object owner)
|
Object |
MetaType.nullSafeGet(ResultSet rs,
String[] names,
SessionImplementor session,
Object owner)
|
Object |
Type.nullSafeGet(ResultSet rs,
String[] names,
SessionImplementor session,
Object owner)
Extract a value of the mapped class from the JDBC result set. |
Object |
ComponentType.nullSafeGet(ResultSet rs,
String[] names,
SessionImplementor session,
Object owner)
|
Object |
StringClobType.nullSafeGet(ResultSet rs,
String[] names,
SessionImplementor session,
Object owner)
Deprecated. |
Object |
AbstractLobType.nullSafeGet(ResultSet rs,
String[] names,
SessionImplementor session,
Object owner)
Deprecated. |
Object |
CollectionType.nullSafeGet(ResultSet rs,
String[] name,
SessionImplementor session,
Object owner)
|
Object |
AnyType.nullSafeGet(ResultSet rs,
String[] names,
SessionImplementor session,
Object owner)
|
Object |
EnumType.nullSafeGet(ResultSet rs,
String[] names,
SessionImplementor session,
Object owner)
|
Object |
CustomType.nullSafeGet(ResultSet rs,
String[] names,
SessionImplementor session,
Object owner)
|
Object |
EntityType.nullSafeGet(ResultSet rs,
String[] names,
SessionImplementor session,
Object owner)
Extract a value of the mapped class from the JDBC result set. |
Object |
NullableType.nullSafeGet(ResultSet rs,
String[] names,
SessionImplementor session,
Object owner)
Deprecated. |
T |
SingleColumnType.nullSafeGet(ResultSet rs,
String name,
SessionImplementor session)
Get a column value from a result set by name. |
Object |
CompositeCustomType.nullSafeGet(ResultSet rs,
String columnName,
SessionImplementor session,
Object owner)
|
Object |
MetaType.nullSafeGet(ResultSet rs,
String name,
SessionImplementor session,
Object owner)
|
Object |
Type.nullSafeGet(ResultSet rs,
String name,
SessionImplementor session,
Object owner)
Extract a value of the mapped class from the JDBC result set. |
Object |
ComponentType.nullSafeGet(ResultSet rs,
String name,
SessionImplementor session,
Object owner)
|
Object |
AbstractLobType.nullSafeGet(ResultSet rs,
String name,
SessionImplementor session,
Object owner)
Deprecated. |
Object |
AnyType.nullSafeGet(ResultSet rs,
String name,
SessionImplementor session,
Object owner)
|
Object |
CustomType.nullSafeGet(ResultSet rs,
String columnName,
SessionImplementor session,
Object owner)
|
Object |
EntityType.nullSafeGet(ResultSet rs,
String name,
SessionImplementor session,
Object owner)
Extract a value of the mapped class from the JDBC result set. |
Object |
NullableType.nullSafeGet(ResultSet rs,
String name,
SessionImplementor session,
Object owner)
Deprecated. |
void |
NullableType.nullSafeSet(PreparedStatement st,
Object value,
int index)
Deprecated. |
void |
CompositeCustomType.nullSafeSet(PreparedStatement st,
Object value,
int index,
boolean[] settable,
SessionImplementor session)
|
void |
AbstractSingleColumnStandardBasicType.nullSafeSet(PreparedStatement st,
Object value,
int index,
boolean[] settable,
SessionImplementor session)
Bind a value represented by an instance of the mapped class to the JDBC prepared
statement, ignoring some columns as dictated by the 'settable' parameter. |
void |
MetaType.nullSafeSet(PreparedStatement st,
Object value,
int index,
boolean[] settable,
SessionImplementor session)
|
void |
Type.nullSafeSet(PreparedStatement st,
Object value,
int index,
boolean[] settable,
SessionImplementor session)
Bind a value represented by an instance of the mapped class to the JDBC prepared
statement, ignoring some columns as dictated by the 'settable' parameter. |
void |
ComponentType.nullSafeSet(PreparedStatement st,
Object value,
int begin,
boolean[] settable,
SessionImplementor session)
|
void |
AbstractLobType.nullSafeSet(PreparedStatement st,
Object value,
int index,
boolean[] settable,
SessionImplementor session)
Deprecated. |
void |
ManyToOneType.nullSafeSet(PreparedStatement st,
Object value,
int index,
boolean[] settable,
SessionImplementor session)
|
void |
CollectionType.nullSafeSet(PreparedStatement st,
Object value,
int index,
boolean[] settable,
SessionImplementor session)
|
void |
AnyType.nullSafeSet(PreparedStatement st,
Object value,
int index,
boolean[] settable,
SessionImplementor session)
|
void |
CustomType.nullSafeSet(PreparedStatement st,
Object value,
int index,
boolean[] settable,
SessionImplementor session)
|
void |
NullableType.nullSafeSet(PreparedStatement st,
Object value,
int index,
boolean[] settable,
SessionImplementor session)
Deprecated. |
void |
CompositeCustomType.nullSafeSet(PreparedStatement st,
Object value,
int index,
SessionImplementor session)
|
void |
MetaType.nullSafeSet(PreparedStatement st,
Object value,
int index,
SessionImplementor session)
|
void |
Type.nullSafeSet(PreparedStatement st,
Object value,
int index,
SessionImplementor session)
Bind a value represented by an instance of the mapped class to the JDBC prepared
statement. |
void |
ComponentType.nullSafeSet(PreparedStatement st,
Object value,
int begin,
SessionImplementor session)
|
void |
StringClobType.nullSafeSet(PreparedStatement st,
Object value,
int index,
SessionImplementor session)
Deprecated. |
void |
AbstractLobType.nullSafeSet(PreparedStatement st,
Object value,
int index,
SessionImplementor session)
Deprecated. |
void |
ManyToOneType.nullSafeSet(PreparedStatement st,
Object value,
int index,
SessionImplementor session)
|
void |
CollectionType.nullSafeSet(PreparedStatement st,
Object value,
int index,
SessionImplementor session)
|
void |
AnyType.nullSafeSet(PreparedStatement st,
Object value,
int index,
SessionImplementor session)
|
void |
EnumType.nullSafeSet(PreparedStatement st,
Object value,
int index,
SessionImplementor session)
|
void |
CustomType.nullSafeSet(PreparedStatement st,
Object value,
int index,
SessionImplementor session)
|
void |
NullableType.nullSafeSet(PreparedStatement st,
Object value,
int index,
SessionImplementor session)
Deprecated. |
String |
NullableType.nullSafeToString(Object value)
Deprecated. A null-safe version of NullableType.toString(Object). |
protected String |
CollectionType.renderLoggableString(Object value,
SessionFactoryImplementor factory)
|
protected String |
CustomCollectionType.renderLoggableString(Object value,
SessionFactoryImplementor factory)
|
Object |
StringClobType.replace(Object original,
Object target,
Object owner)
Deprecated. |
Object |
EnumType.replace(Object original,
Object target,
Object owner)
|
Object |
CompositeCustomType.replace(Object original,
Object target,
SessionImplementor session,
Object owner,
Map copyCache)
|
Object |
SerializableToBlobType.replace(Object original,
Object target,
SessionImplementor session,
Object owner,
Map copyCache)
|
Object |
Type.replace(Object original,
Object target,
SessionImplementor session,
Object owner,
Map copyCache)
During merge, replace the existing (target) value in the entity we are merging to with a new (original) value from the detached entity we are merging. |
Object |
ComponentType.replace(Object original,
Object target,
SessionImplementor session,
Object owner,
Map copyCache)
|
Object |
ByteArrayBlobType.replace(Object original,
Object target,
SessionImplementor session,
Object owner,
Map copyCache)
Deprecated. |
Object |
MutableType.replace(Object original,
Object target,
SessionImplementor session,
Object owner,
Map copyCache)
Deprecated. |
Object |
CollectionType.replace(Object original,
Object target,
SessionImplementor session,
Object owner,
Map copyCache)
During merge, replace the existing (target) value in the entity we are merging to with a new (original) value from the detached entity we are merging. |
Object |
AnyType.replace(Object original,
Object target,
SessionImplementor session,
Object owner,
Map copyCache)
|
Object |
CustomType.replace(Object original,
Object target,
SessionImplementor session,
Object owner,
Map copyCache)
|
Object |
EntityType.replace(Object original,
Object target,
SessionImplementor session,
Object owner,
Map copyCache)
During merge, replace the existing (target) value in the entity we are merging to with a new (original) value from the detached entity we are merging. |
Object |
ImmutableType.replace(Object original,
Object target,
SessionImplementor session,
Object owner,
Map copyCache)
Deprecated. |
Object |
Type.replace(Object original,
Object target,
SessionImplementor session,
Object owner,
Map copyCache,
ForeignKeyDirection foreignKeyDirection)
During merge, replace the existing (target) value in the entity we are merging to with a new (original) value from the detached entity we are merging. |
Object |
ComponentType.replace(Object original,
Object target,
SessionImplementor session,
Object owner,
Map copyCache,
ForeignKeyDirection foreignKeyDirection)
|
Object |
AbstractType.replace(Object original,
Object target,
SessionImplementor session,
Object owner,
Map copyCache,
ForeignKeyDirection foreignKeyDirection)
|
Object |
ArrayType.replaceElements(Object original,
Object target,
Object owner,
Map copyCache,
SessionImplementor session)
|
Object |
MapType.replaceElements(Object original,
Object target,
Object owner,
Map copyCache,
SessionImplementor session)
|
Object |
CustomCollectionType.replaceElements(Object original,
Object target,
Object owner,
Map copyCache,
SessionImplementor session)
|
Object |
Type.resolve(Object value,
SessionImplementor session,
Object owner)
The second phase of 2-phase loading. |
Object |
ComponentType.resolve(Object value,
SessionImplementor session,
Object owner)
|
Object |
CollectionType.resolve(Object value,
SessionImplementor session,
Object owner)
|
Object |
AnyType.resolve(Object value,
SessionImplementor session,
Object owner)
|
Object |
EntityType.resolve(Object value,
SessionImplementor session,
Object owner)
Resolve an identifier or unique key value |
Object |
AbstractType.resolve(Object value,
SessionImplementor session,
Object owner)
|
Object |
AbstractStandardBasicType.resolve(Object value,
SessionImplementor session,
Object owner)
|
protected Object |
EntityType.resolveIdentifier(Serializable id,
SessionImplementor session)
Resolve an identifier via a load. |
Object |
Type.semiResolve(Object value,
SessionImplementor session,
Object owner)
Given a hydrated, but unresolved value, return a value that may be used to reconstruct property-ref associations. |
Object |
ComponentType.semiResolve(Object value,
SessionImplementor session,
Object owner)
|
Object |
CollectionType.semiResolve(Object value,
SessionImplementor session,
Object owner)
|
Object |
AnyType.semiResolve(Object value,
SessionImplementor session,
Object owner)
|
Object |
AbstractType.semiResolve(Object value,
SessionImplementor session,
Object owner)
|
Object |
AbstractStandardBasicType.semiResolve(Object value,
SessionImplementor session,
Object owner)
|
void |
AbstractLongStringType.set(PreparedStatement st,
Object value,
int index)
Deprecated. |
void |
AbstractBynaryType.set(PreparedStatement st,
Object value,
int index)
Deprecated. |
abstract void |
NullableType.set(PreparedStatement st,
Object value,
int index)
Deprecated. Set a parameter value without worrying about the possibility of null values. |
void |
SingleColumnType.set(PreparedStatement st,
T value,
int index,
SessionImplementor session)
Set a parameter value without worrying about the possibility of null values. |
void |
AbstractStandardBasicType.set(PreparedStatement st,
T value,
int index,
SessionImplementor session)
|
void |
CompositeCustomType.setPropertyValues(Object component,
Object[] values,
EntityMode entityMode)
|
void |
ComponentType.setPropertyValues(Object component,
Object[] values,
EntityMode entityMode)
|
void |
CompositeType.setPropertyValues(Object component,
Object[] values,
EntityMode entityMode)
Inject property values onto the given component instance An optional operation |
void |
AnyType.setPropertyValues(Object component,
Object[] values,
EntityMode entityMode)
|
void |
CompositeCustomType.setToXMLNode(org.dom4j.Node node,
Object value,
SessionFactoryImplementor factory)
|
void |
SerializableToBlobType.setToXMLNode(org.dom4j.Node node,
Object value,
SessionFactoryImplementor factory)
|
void |
MetaType.setToXMLNode(org.dom4j.Node node,
Object value,
SessionFactoryImplementor factory)
|
void |
Type.setToXMLNode(org.dom4j.Node node,
Object value,
SessionFactoryImplementor factory)
A representation of the value to be embedded in an XML element. |
void |
ComponentType.setToXMLNode(org.dom4j.Node node,
Object value,
SessionFactoryImplementor factory)
|
void |
ByteArrayBlobType.setToXMLNode(org.dom4j.Node node,
Object value,
SessionFactoryImplementor factory)
Deprecated. |
void |
CollectionType.setToXMLNode(org.dom4j.Node node,
Object value,
SessionFactoryImplementor factory)
|
void |
CustomType.setToXMLNode(org.dom4j.Node node,
Object value,
SessionFactoryImplementor factory)
|
void |
EntityType.setToXMLNode(org.dom4j.Node node,
Object value,
SessionFactoryImplementor factory)
A representation of the value to be embedded in an XML element. |
void |
NullableType.setToXMLNode(org.dom4j.Node xml,
Object value,
SessionFactoryImplementor factory)
Deprecated. |
String |
ArrayType.toLoggableString(Object value,
SessionFactoryImplementor factory)
|
String |
CompositeCustomType.toLoggableString(Object value,
SessionFactoryImplementor factory)
|
String |
SerializableToBlobType.toLoggableString(Object value,
SessionFactoryImplementor factory)
|
String |
MetaType.toLoggableString(Object value,
SessionFactoryImplementor factory)
|
String |
Type.toLoggableString(Object value,
SessionFactoryImplementor factory)
Generate a representation of the value for logging purposes. |
String |
ComponentType.toLoggableString(Object value,
SessionFactoryImplementor factory)
|
String |
CollectionType.toLoggableString(Object value,
SessionFactoryImplementor factory)
|
String |
AnyType.toLoggableString(Object value,
SessionFactoryImplementor factory)
|
String |
CustomType.toLoggableString(Object value,
SessionFactoryImplementor factory)
|
abstract String |
NullableType.toString(Object value)
Deprecated. |
String |
SingleColumnType.toString(T value)
|
String |
StringRepresentableType.toString(T value)
Render the value to the string representation. |
String |
MetaType.toXMLString(Object value,
SessionFactoryImplementor factory)
|
String |
NullableType.toXMLString(Object value,
SessionFactoryImplementor pc)
Deprecated. |
String |
XmlRepresentableType.toXMLString(T value,
SessionFactoryImplementor factory)
|
String |
AbstractStandardBasicType.toXMLString(T value,
SessionFactoryImplementor factory)
|
| Uses of HibernateException in org.hibernate.type.descriptor.java |
|---|
| Methods in org.hibernate.type.descriptor.java that return HibernateException | |
|---|---|
protected HibernateException |
AbstractTypeDescriptor.unknownUnwrap(Class conversionType)
|
protected HibernateException |
AbstractTypeDescriptor.unknownWrap(Class conversionType)
|
| Uses of HibernateException in org.hibernate.usertype |
|---|
| Methods in org.hibernate.usertype that throw HibernateException | |
|---|---|
Object |
UserType.assemble(Serializable cached,
Object owner)
Reconstruct an object from the cacheable representation. |
Object |
CompositeUserType.assemble(Serializable cached,
SessionImplementor session,
Object owner)
Reconstruct an object from the cacheable representation. |
Object |
UserType.deepCopy(Object value)
Return a deep copy of the persistent state, stopping at entities and at collections. |
Object |
CompositeUserType.deepCopy(Object value)
Return a deep copy of the persistent state, stopping at entities and at collections. |
Serializable |
UserType.disassemble(Object value)
Transform the object into its cacheable representation. |
Serializable |
CompositeUserType.disassemble(Object value,
SessionImplementor session)
Transform the object into its cacheable representation. |
boolean |
UserType.equals(Object x,
Object y)
Compare two instances of the class mapped by this type for persistence "equality". |
boolean |
CompositeUserType.equals(Object x,
Object y)
Compare two instances of the class mapped by this type for persistence "equality". |
Object |
CompositeUserType.getPropertyValue(Object component,
int property)
Get the value of a property. |
int |
UserType.hashCode(Object x)
Get a hashcode for the instance, consistent with persistence "equality" |
int |
CompositeUserType.hashCode(Object x)
Get a hashcode for the instance, consistent with persistence "equality" |
PersistentCollection |
UserCollectionType.instantiate(SessionImplementor session,
CollectionPersister persister)
Instantiate an uninitialized instance of the collection wrapper |
Object |
UserType.nullSafeGet(ResultSet rs,
String[] names,
SessionImplementor session,
Object owner)
Retrieve an instance of the mapped class from a JDBC resultset. |
Object |
CompositeUserType.nullSafeGet(ResultSet rs,
String[] names,
SessionImplementor session,
Object owner)
Retrieve an instance of the mapped class from a JDBC resultset. |
void |
UserType.nullSafeSet(PreparedStatement st,
Object value,
int index,
SessionImplementor session)
Write an instance of the mapped class to a prepared statement. |
void |
CompositeUserType.nullSafeSet(PreparedStatement st,
Object value,
int index,
SessionImplementor session)
Write an instance of the mapped class to a prepared statement. |
Object |
UserType.replace(Object original,
Object target,
Object owner)
During merge, replace the existing (target) value in the entity we are merging to with a new (original) value from the detached entity we are merging. |
Object |
CompositeUserType.replace(Object original,
Object target,
SessionImplementor session,
Object owner)
During merge, replace the existing (target) value in the entity we are merging to with a new (original) value from the detached entity we are merging. |
Object |
UserCollectionType.replaceElements(Object original,
Object target,
CollectionPersister persister,
Object owner,
Map copyCache,
SessionImplementor session)
Replace the elements of a collection with the elements of another collection |
void |
CompositeUserType.setPropertyValue(Object component,
int property,
Object value)
Set the value of a property. |
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||