Package | Description |
---|---|
org.hibernate |
This package defines the central Hibernate APIs.
|
org.hibernate.action |
This package defines "actions" that are scheduled for
asycnchronous execution by the event listeners.
|
org.hibernate.cache |
This package defines APIs/SPIs and implementations for the Hibernate second-level cache.
|
org.hibernate.cache.entry |
This package defines formats for disassembled state
kept in the second level cache.
|
org.hibernate.cfg |
This package defines APIs for configuring Hibernate, and classes
for building the Hibernate configuration-time metamodel.
|
org.hibernate.classic |
This package implements backward-compatibility with Hibernate 2.1
APIs now deprecated in Hibernate3.
|
org.hibernate.collection |
This package defines a framework for collection wrappers.
|
org.hibernate.connection |
This package abstracts the mechanism for obtaining
a JDBC connection.
|
org.hibernate.context | |
org.hibernate.criterion |
A framework for defining restriction criteria and order criteria.
|
org.hibernate.dialect |
This package abstracts the SQL dialect of the underlying database.
|
org.hibernate.dialect.resolver | |
org.hibernate.ejb | |
org.hibernate.ejb.connection | |
org.hibernate.ejb.transaction | |
org.hibernate.engine |
This package contains classes that are "shared" by other packages,
and implementations of some key algorithms.
|
org.hibernate.engine.query | |
org.hibernate.engine.transaction | |
org.hibernate.envers | |
org.hibernate.envers.entities | |
org.hibernate.envers.entities.mapper.relation.lazy | |
org.hibernate.envers.exception | |
org.hibernate.envers.reader | |
org.hibernate.event |
This package defines an event framework for Hibernate.
|
org.hibernate.event.def |
This package defines a default set of event listeners that
implements the default behaviors of Hibernate.
|
org.hibernate.exception |
This package is a fork of Apache commons-lang nestable exceptions.
|
org.hibernate.hql |
This package defines the interface between Hibernate and
the HQL query parser implementation (to allow switching
between the 2.x and 3.0 HQL parsers).
|
org.hibernate.hql.ast |
An ANTLR-based parser for Hibernate Query Language.
|
org.hibernate.hql.ast.exec | |
org.hibernate.hql.classic |
This package contains the Hibernate 2.x query parser which
is being end-of-lifed.
|
org.hibernate.id |
This package contains internal implementation classes for the
main API interfaces.
|
org.hibernate.id.enhanced | |
org.hibernate.impl |
This package contains implementations of the
central Hibernate APIs, especially the
Hibernate session.
|
org.hibernate.intercept |
This package implements an interception
mechanism for lazy property fetching,
based on CGLIB bytecode instrumentation.
|
org.hibernate.jdbc |
This package abstracts the mechanism for dispatching SQL statements
to the database, and implements interaction with JDBC.
|
org.hibernate.jmx |
This package exposes a Hibernate instance via JMX.
|
org.hibernate.loader |
This package defines functionality for processing JDBC
result sets and returning complex graphs of persistent
objects.
|
org.hibernate.loader.collection |
This package defines collection initializers
|
org.hibernate.loader.criteria |
This package defines the criteria query compiler and loader
|
org.hibernate.loader.custom |
This package defines a framework for custom loaders that accept
handwritten SQL
|
org.hibernate.loader.custom.sql | |
org.hibernate.loader.entity |
This package defines entity loaders
|
org.hibernate.loader.hql |
This package defines a loader for the AST-based query parser
|
org.hibernate.mapping |
This package defines the Hibernate configuration-time metamodel.
|
org.hibernate.metadata |
This package defines an API for accessing the Hibernate
runtime metamodel.
|
org.hibernate.persister |
A persister defines a mapping strategy for a collection
or entity.
|
org.hibernate.persister.collection |
This package abstracts the persistence mechanism for collections.
|
org.hibernate.persister.entity |
This package abstracts persistence mechanisms for
entities, and defines the Hibernate runtime
metamodel.
|
org.hibernate.pretty |
Classes for pretty printing things for exception
and log messages.
|
org.hibernate.property |
This package abstracts the notion of a "property" of
an entity.
|
org.hibernate.proxy |
This package defines a framework for lazy-initializing
entity proxies.
|
org.hibernate.proxy.dom4j | |
org.hibernate.proxy.map | |
org.hibernate.proxy.pojo.cglib | |
org.hibernate.proxy.pojo.javassist | |
org.hibernate.secure |
Declarative security for CRUD operations on entities.
|
org.hibernate.sql.ordering.antlr | |
org.hibernate.testing.junit.functional | |
org.hibernate.testing.tm |
Defines a simplified JTA TransactionManager and transactional connection pool
designed for use in test suite and simple usage scenarios.
|
org.hibernate.tool.hbm2ddl |
The hbm2ddl tool.
|
org.hibernate.transaction |
This package abstracts the underlying transaction mechanism
(JTA or JDBC) and provides strategies for obtaining application
server TransactionManagers.
|
org.hibernate.tuple.component | |
org.hibernate.tuple.entity | |
org.hibernate.type |
A Hibernate Type is a strategy for mapping a
Java property type to a JDBC type or types.
|
org.hibernate.type.descriptor.java | |
org.hibernate.usertype |
Interfaces for user-defined custom types.
|
org.hibernate.util |
Utility classes.
|
Modifier and Type | Class and Description |
---|---|
class |
AnnotationException
Annotation related exception.
|
class |
CallbackException
Should be thrown by persistent objects from Lifecycle
or Interceptor callbacks.
|
class |
DuplicateMappingException
Raised whenever a duplicate for a certain type occurs.
|
class |
InstantiationException
Thrown if Hibernate can't instantiate an entity or component
class at runtime.
|
class |
InvalidMappingException
Thrown when a mapping is found to be invalid.
|
class |
JDBCException
Wraps an SQLException.
|
class |
LazyInitializationException
Indicates access to unfetched data outside of a session context.
|
class |
MappingException
An exception that usually occurs at configuration time, rather
than runtime, as a result of something screwy in the O-R mappings.
|
class |
MappingNotFoundException
Thrown when a resource for a mapping could not be found.
|
class |
NonUniqueObjectException
This exception is thrown when an operation would
break session-scoped identity.
|
class |
NonUniqueResultException
Thrown when the application calls Query.uniqueResult() and
the query returned more than one result.
|
class |
ObjectDeletedException
Thrown when the user tries to do something illegal with a deleted
object.
|
class |
ObjectNotFoundException
Thrown when Session.load() fails to select a row with
the given primary key (identifier value).
|
class |
OptimisticLockException
Throw when an optimistic locking conflict occurs.
|
class |
PersistentObjectException
Thrown when the user passes a persistent instance to a Session
method that expects a transient instance.
|
class |
PessimisticLockException
Thrown when a pessimistic locking conflict occurs.
|
class |
PropertyAccessException
A problem occurred accessing a property of an instance of a
persistent class by reflection, or via CGLIB.
|
class |
PropertyNotFoundException
Indicates that an expected getter or setter method could not be
found on a class.
|
class |
PropertyValueException
Thrown when the (illegal) value of a property can not be persisted.
|
class |
QueryException
A problem occurred translating a Hibernate query to SQL
due to invalid query syntax, etc.
|
class |
QueryParameterException
Parameter invalid or not found in the query
|
class |
QueryTimeoutException
Thrown when a database query timeout occurs.
|
class |
SessionException
Thrown when the user calls a method of a
Session that is in an
inappropropriate state for the given call (for example, the the session
is closed or disconnected). |
class |
StaleObjectStateException
A StaleStateException that carries information
about a particular entity instance that was the source
of the failure.
|
class |
StaleStateException
Thrown when a version number or timestamp check failed, indicating that the
Session contained stale data (when using long transactions
with versioning).
|
class |
TransactionException
Indicates that a transaction could not be begun, committed
or rolled back.
|
class |
TransientObjectException
Thrown when the user passes a transient instance to a Session
method that expects a persistent instance.
|
class |
TypeMismatchException
Used when a user provided type does not match the expected one
|
class |
UnknownProfileException
Used to indicate a request against an unknown profile name.
|
class |
UnresolvableObjectException
Thrown when Hibernate could not resolve an object by id, especially when
loading an association.
|
class |
WrongClassException
Thrown when Session.load() selects a row with
the given primary key (identifier value) but the row's
discriminator value specifies a subclass that is not
assignable to the class requested by the user.
|
Modifier and Type | Method and Description |
---|---|
void |
ScrollableResults.afterLast()
Go to a location just after the last result
|
void |
ScrollableResults.beforeFirst()
Go to a location just before first result (this is the initial location)
|
void |
Transaction.begin()
Begin a new transaction.
|
Transaction |
Session.beginTransaction()
Begin a unit of work and return the associated Transaction object.
|
void |
Session.cancelQuery()
Cancel the execution of the current query.
|
void |
ScrollableResults.close()
Release resources immediately.
|
void |
SessionFactory.close()
Destroy this SessionFactory and release all resources (caches,
connection pools, etc).
|
Connection |
Session.close()
End the session by releasing the JDBC connection and cleaning up.
|
static void |
Hibernate.close(Iterator iterator)
Close an Iterator created by iterate() immediately,
instead of waiting until the session is closed or disconnected.
|
void |
Transaction.commit()
Flush the associated Session and end the unit of work (unless
we are in
FlushMode.MANUAL . |
Connection |
Session.connection()
Deprecated.
(scheduled for removal in 4.x). Replacement depends on need; for doing direct JDBC stuff use
Session.doWork(org.hibernate.jdbc.Work) ; for opening a 'temporary Session' use (TBD). |
Criteria |
Criteria.createAlias(String associationPath,
String alias)
Join an association, assigning an alias to the joined association.
|
Criteria |
Criteria.createAlias(String associationPath,
String alias,
int joinType)
Join an association using the specified join-type, assigning an alias
to the joined association.
|
Criteria |
Criteria.createAlias(String associationPath,
String alias,
int joinType,
Criterion withClause)
Join an association using the specified join-type, assigning an alias
to the joined association.
|
Criteria |
Criteria.createCriteria(String associationPath)
Create a new Criteria, "rooted" at the associated entity.
|
Criteria |
Criteria.createCriteria(String associationPath,
int joinType)
Create a new Criteria, "rooted" at the associated entity, using the
specified join type.
|
Criteria |
Criteria.createCriteria(String associationPath,
String alias)
Create a new Criteria, "rooted" at the associated entity,
assigning the given alias.
|
Criteria |
Criteria.createCriteria(String associationPath,
String alias,
int joinType)
Create a new Criteria, "rooted" at the associated entity,
assigning the given alias and using the specified join type.
|
Criteria |
Criteria.createCriteria(String associationPath,
String alias,
int joinType,
Criterion withClause)
Create a new Criteria, "rooted" at the associated entity,
assigning the given alias and using the specified join type.
|
Query |
Session.createFilter(Object collection,
String queryString)
Create a new instance of Query for the given collection and filter string.
|
Query |
Session.createQuery(String queryString)
Create a new instance of Query for the given HQL query string.
|
SQLQuery |
Session.createSQLQuery(String queryString)
Create a new instance of SQLQuery for the given SQL query string.
|
SQLQuery |
StatelessSession.createSQLQuery(String queryString)
Create a new instance of SQLQuery for the given SQL query string.
|
void |
Session.delete(Object object)
Remove a persistent instance from the datastore.
|
void |
Session.delete(String entityName,
Object object)
Remove a persistent instance from the datastore.
|
Connection |
Session.disconnect()
Disconnect the Session from the current JDBC connection.
|
void |
Session.doWork(Work work)
Controller for allowing users to perform JDBC related work using the Connection
managed by this Session.
|
void |
SessionFactory.evict(Class persistentClass)
Deprecated.
Use
Cache.evictEntityRegion(Class) accessed through
SessionFactory.getCache() instead. |
void |
SessionFactory.evict(Class persistentClass,
Serializable id)
Deprecated.
Use
Cache.containsEntity(Class, Serializable) accessed through
SessionFactory.getCache() instead. |
void |
Session.evict(Object object)
Remove this instance from the session cache.
|
void |
SessionFactory.evictCollection(String roleName)
Deprecated.
Use
Cache.evictCollectionRegion(String) accessed through
SessionFactory.getCache() instead. |
void |
SessionFactory.evictCollection(String roleName,
Serializable id)
Deprecated.
Use
Cache.evictCollection(String,Serializable) accessed through
SessionFactory.getCache() instead. |
void |
SessionFactory.evictEntity(String entityName)
Deprecated.
Use
Cache.evictEntityRegion(String) accessed through
SessionFactory.getCache() instead. |
void |
SessionFactory.evictEntity(String entityName,
Serializable id)
Deprecated.
Use
Cache.evictEntity(String,Serializable) accessed through
SessionFactory.getCache() instead. |
void |
SessionFactory.evictQueries()
Deprecated.
Use
Cache.evictQueryRegions() accessed through
SessionFactory.getCache() instead. |
void |
SessionFactory.evictQueries(String cacheRegion)
Deprecated.
Use
Cache.evictQueryRegion(String) accessed through
SessionFactory.getCache() instead. |
int |
Query.executeUpdate()
Execute the update or delete statement.
|
boolean |
ScrollableResults.first()
Go to the first result
|
void |
Session.flush()
Force this session to flush.
|
Object[] |
ScrollableResults.get()
Get the current row of results
|
Object |
Session.get(Class clazz,
Serializable id)
Return the persistent instance of the given entity class with the given identifier,
or null if there is no such persistent instance.
|
Object |
Session.get(Class clazz,
Serializable id,
LockMode lockMode)
Deprecated.
LockMode parameter should be replaced with LockOptions
|
Object |
Session.get(Class clazz,
Serializable id,
LockOptions lockOptions)
Return the persistent instance of the given entity class with the given identifier,
or null if there is no such persistent instance.
|
Object |
ScrollableResults.get(int i)
Get the ith object in the current row of results, without
initializing any other results in the row.
|
Object |
Session.get(String entityName,
Serializable id)
Return the persistent instance of the given named entity with the given identifier,
or null if there is no such persistent instance.
|
Object |
Session.get(String entityName,
Serializable id,
LockMode lockMode)
Deprecated.
LockMode parameter should be replaced with LockOptions
|
Object |
Session.get(String entityName,
Serializable id,
LockOptions lockOptions)
Return the persistent instance of the given entity class with the given identifier,
or null if there is no such persistent instance.
|
BigDecimal |
ScrollableResults.getBigDecimal(int col)
Convenience method to read a big_decimal
|
BigInteger |
ScrollableResults.getBigInteger(int col)
Convenience method to read a big_integer
|
byte[] |
ScrollableResults.getBinary(int col)
Convenience method to read a binary
|
Blob |
ScrollableResults.getBlob(int col)
Convenience method to read a blob
|
Boolean |
ScrollableResults.getBoolean(int col)
Convenience method to read a boolean
|
Byte |
ScrollableResults.getByte(int col)
Convenience method to read a byte
|
Calendar |
ScrollableResults.getCalendar(int col)
Convenience method to read a calendar or calendar_date
|
Character |
ScrollableResults.getCharacter(int col)
Convenience method to read a character
|
Clob |
ScrollableResults.getClob(int col)
Convenience method to read a clob
|
LockMode |
Session.getCurrentLockMode(Object object)
Determine the current lock mode of the given object.
|
Session |
SessionFactory.getCurrentSession()
Obtains the current session.
|
Date |
ScrollableResults.getDate(int col)
Convenience method to read a date, time or timestamp
|
Double |
ScrollableResults.getDouble(int col)
Convenience method to read a double
|
String |
Session.getEntityName(Object object)
Return the entity name for a persistent entity
|
FilterDefinition |
SessionFactory.getFilterDefinition(String filterName)
Obtain the definition of a filter by name.
|
Float |
ScrollableResults.getFloat(int col)
Convenience method to read a float
|
Serializable |
Session.getIdentifier(Object object)
Return the identifier value of the given entity as associated with this
session.
|
Integer |
ScrollableResults.getInteger(int col)
Convenience method to read an integer
|
Locale |
ScrollableResults.getLocale(int col)
Convenience method to read a locale
|
Long |
ScrollableResults.getLong(int col)
Convenience method to read a long
|
String[] |
Query.getNamedParameters()
Return the names of all named parameters of the query.
|
Query |
Session.getNamedQuery(String queryName)
Obtain an instance of Query for a named query string defined in the
mapping file.
|
String[] |
Query.getReturnAliases()
Return the HQL select clause aliases (if any)
|
Type[] |
Query.getReturnTypes()
Return the Hibernate types of the query result set.
|
int |
ScrollableResults.getRowNumber()
Get the current location in the result set.
|
Short |
ScrollableResults.getShort(int col)
Convenience method to read a short
|
String |
ScrollableResults.getString(int col)
Convenience method to read a string
|
String |
ScrollableResults.getText(int col)
Convenience method to read text
|
TimeZone |
ScrollableResults.getTimeZone(int col)
Convenience method to read a timezone
|
static void |
Hibernate.initialize(Object proxy)
Force initialization of a proxy or persistent collection.
|
boolean |
Transaction.isActive()
Is this transaction still active?
Again, this only returns information in relation to the
local transaction, not the actual underlying transaction.
|
boolean |
Session.isDirty()
Does this session contain any changes which must be synchronized with
the database? In other words, would any DML operations be executed if
we flushed this session?
|
boolean |
ScrollableResults.isFirst()
Is this the first result?
|
boolean |
ScrollableResults.isLast()
Is this the last result?
|
Iterator |
Query.iterate()
Return the query results as an Iterator.
|
boolean |
ScrollableResults.last()
Go to the last result
|
List |
Query.list()
Return the query results as a List.
|
List |
Criteria.list()
Get the results.
|
Object |
Session.load(Class theClass,
Serializable id)
Return the persistent instance of the given entity class with the given identifier,
assuming that the instance exists.
|
Object |
Session.load(Class theClass,
Serializable id,
LockMode lockMode)
Deprecated.
LockMode parameter should be replaced with LockOptions
|
Object |
Session.load(Class theClass,
Serializable id,
LockOptions lockOptions)
Return the persistent instance of the given entity class with the given identifier,
obtaining the specified lock mode, assuming the instance exists.
|
void |
Session.load(Object object,
Serializable id)
Read the persistent state associated with the given identifier into the given transient
instance.
|
Object |
Session.load(String entityName,
Serializable id)
Return the persistent instance of the given entity class with the given identifier,
assuming that the instance exists.
|
Object |
Session.load(String entityName,
Serializable id,
LockMode lockMode)
Deprecated.
LockMode parameter should be replaced with LockOptions
|
Object |
Session.load(String entityName,
Serializable id,
LockOptions lockOptions)
Return the persistent instance of the given entity class with the given identifier,
obtaining the specified lock mode, assuming the instance exists.
|
void |
Session.LockRequest.lock(Object object) |
void |
Session.lock(Object object,
LockMode lockMode)
Deprecated.
instead call buildLockRequest(LockMode).lock(object)
|
void |
Session.LockRequest.lock(String entityName,
Object object) |
void |
Session.lock(String entityName,
Object object,
LockMode lockMode)
Deprecated.
instead call buildLockRequest(LockMode).lock(entityName, object)
|
Object |
Session.merge(Object object)
Copy the state of the given object onto the persistent object with the same
identifier.
|
Object |
Session.merge(String entityName,
Object object)
Copy the state of the given object onto the persistent object with the same
identifier.
|
boolean |
ScrollableResults.next()
Advance to the next result
|
Session |
SessionFactory.openSession()
Open a
Session . |
Session |
SessionFactory.openSession(Interceptor interceptor)
Open a
Session , utilizing the specified Interceptor . |
static ConnectionReleaseMode |
ConnectionReleaseMode.parse(String modeName)
Determine the correct ConnectionReleaseMode instance based on the given
name.
|
void |
Session.persist(Object object)
Make a transient instance persistent.
|
void |
Session.persist(String entityName,
Object object)
Make a transient instance persistent.
|
boolean |
ScrollableResults.previous()
Retreat to the previous result
|
void |
Session.reconnect()
Deprecated.
Manual reconnection is only needed in the case of
application-supplied connections, in which case the
Session.reconnect(java.sql.Connection) for should be used. |
void |
Session.reconnect(Connection connection)
Reconnect to the given JDBC connection.
|
void |
Session.refresh(Object object)
Re-read the state of the given instance from the underlying database.
|
void |
Session.refresh(Object object,
LockMode lockMode)
Deprecated.
LockMode parameter should be replaced with LockOptions
|
void |
Session.refresh(Object object,
LockOptions lockOptions)
Re-read the state of the given instance from the underlying database, with
the given LockMode.
|
void |
Transaction.registerSynchronization(Synchronization synchronization)
Register a user synchronization callback for this transaction.
|
void |
Session.replicate(Object object,
ReplicationMode replicationMode)
Persist the state of the given detached instance, reusing the current
identifier value.
|
void |
Session.replicate(String entityName,
Object object,
ReplicationMode replicationMode)
Persist the state of the given detached instance, reusing the current
identifier value.
|
void |
Transaction.rollback()
Force the underlying transaction to roll back.
|
Serializable |
Session.save(Object object)
Persist the given transient instance, first assigning a generated identifier.
|
Serializable |
Session.save(String entityName,
Object object)
Persist the given transient instance, first assigning a generated identifier.
|
void |
Session.saveOrUpdate(Object object)
Either
Session.save(Object) or Session.update(Object) the given
instance, depending upon resolution of the unsaved-value checks (see the
manual for discussion of unsaved-value checking). |
void |
Session.saveOrUpdate(String entityName,
Object object)
Either
Session.save(String, Object) or Session.update(String, Object)
the given instance, depending upon resolution of the unsaved-value checks
(see the manual for discussion of unsaved-value checking). |
ScrollableResults |
Query.scroll()
Return the query results as ScrollableResults.
|
ScrollableResults |
Criteria.scroll()
Get the results as an instance of
ScrollableResults |
boolean |
ScrollableResults.scroll(int i)
Scroll an arbitrary number of locations
|
ScrollableResults |
Query.scroll(ScrollMode scrollMode)
Return the query results as ScrollableResults.
|
ScrollableResults |
Criteria.scroll(ScrollMode scrollMode)
Get the results as an instance of
ScrollableResults based on the
given scroll mode. |
Criteria |
Criteria.setFetchMode(String associationPath,
FetchMode mode)
Specify an association fetching strategy for an association or a
collection of values.
|
Query |
Query.setParameter(int position,
Object val)
Bind a value to a JDBC-style query parameter.
|
Query |
Query.setParameter(String name,
Object val)
Bind a value to a named query parameter.
|
Query |
Query.setParameterList(String name,
Collection vals)
Bind multiple values to a named query parameter.
|
Query |
Query.setParameterList(String name,
Collection vals,
Type type)
Bind multiple values to a named query parameter.
|
Query |
Query.setParameterList(String name,
Object[] vals)
Bind multiple values to a named query parameter.
|
Query |
Query.setParameterList(String name,
Object[] vals,
Type type)
Bind multiple values to a named query parameter.
|
Query |
Query.setParameters(Object[] values,
Type[] types)
Bind values and types to positional parameters.
|
Query |
Query.setProperties(Map bean)
Bind the values of the given Map for each named parameters of the query,
matching key names with parameter names and mapping value types to
Hibernate types using hueristics.
|
Query |
Query.setProperties(Object bean)
Bind the property values of the given bean to named parameters of the query,
matching property names with parameter names and mapping property types to
Hibernate types using hueristics.
|
boolean |
ScrollableResults.setRowNumber(int rowNumber)
Set the current location in the result set, numbered from either the
first row (row number 0), or the last row (row
number -1).
|
Object |
Query.uniqueResult()
Convenience method to return a single instance that matches
the query, or null if the query returns no results.
|
Object |
Criteria.uniqueResult()
Convenience method to return a single instance that matches
the query, or null if the query returns no results.
|
void |
Session.update(Object object)
Update the persistent instance with the identifier of the given detached
instance.
|
void |
Session.update(String entityName,
Object object)
Update the persistent instance with the identifier of the given detached
instance.
|
void |
Filter.validate()
Perform validation of the filter state.
|
boolean |
Transaction.wasCommitted()
Check if this transaction was successfully committed.
|
boolean |
Transaction.wasRolledBack()
Was this transaction rolled back or set to rollback only?
This only accounts for actions initiated from this local transaction.
|
Modifier and Type | Method and Description |
---|---|
void |
BulkOperationCleanupAction.beforeExecutions() |
void |
Executable.beforeExecutions()
Called before executing any actions.
|
void |
EntityDeleteAction.doAfterTransactionCompletion(boolean success,
SessionImplementor session) |
void |
EntityInsertAction.doAfterTransactionCompletion(boolean success,
SessionImplementor session)
Perform whatever processing is encapsulated here after completion of the transaction.
|
void |
CollectionUpdateAction.execute() |
void |
BulkOperationCleanupAction.execute() |
void |
CollectionRecreateAction.execute() |
void |
Executable.execute()
Execute this action
|
void |
EntityDeleteAction.execute() |
void |
EntityIdentityInsertAction.execute() |
void |
EntityUpdateAction.execute() |
void |
CollectionRemoveAction.execute() |
void |
EntityInsertAction.execute() |
Constructor and Description |
---|
EntityIdentityInsertAction(Object[] state,
Object instance,
EntityPersister persister,
SessionImplementor session,
boolean isDelayed) |
EntityInsertAction(Serializable id,
Object[] state,
Object instance,
Object version,
EntityPersister persister,
SessionImplementor session) |
EntityUpdateAction(Serializable id,
Object[] state,
int[] dirtyProperties,
boolean hasDirtyCollection,
Object[] previousState,
Object previousVersion,
Object nextVersion,
Object instance,
Object rowId,
EntityPersister persister,
SessionImplementor session) |
Modifier and Type | Class and Description |
---|---|
class |
CacheException
Something went wrong in the cache
|
class |
NoCachingEnabledException
Implementation of NoCachingEnabledException.
|
Modifier and Type | Method and Description |
---|---|
List |
StandardQueryCache.get(QueryKey key,
Type[] returnTypes,
boolean isNaturalKeyLookup,
Set spaces,
SessionImplementor session) |
List |
QueryCache.get(QueryKey key,
Type[] returnTypes,
boolean isNaturalKeyLookup,
Set spaces,
SessionImplementor session) |
QueryCache |
QueryCacheFactory.getQueryCache(String regionName,
UpdateTimestampsCache updateTimestampsCache,
Settings settings,
Properties props) |
QueryCache |
StandardQueryCacheFactory.getQueryCache(String regionName,
UpdateTimestampsCache updateTimestampsCache,
Settings settings,
Properties props) |
boolean |
UpdateTimestampsCache.isUpToDate(Set spaces,
Long timestamp) |
boolean |
StandardQueryCache.put(QueryKey key,
Type[] returnTypes,
List result,
boolean isNaturalKeyLookup,
SessionImplementor session) |
boolean |
QueryCache.put(QueryKey key,
Type[] returnTypes,
List result,
boolean isNaturalKeyLookup,
SessionImplementor session) |
Constructor and Description |
---|
StandardQueryCache(Settings settings,
Properties props,
UpdateTimestampsCache updateTimestampsCache,
String regionName) |
UpdateTimestampsCache(Settings settings,
Properties props) |
Modifier and Type | Method and Description |
---|---|
Object[] |
CacheEntry.assemble(Object instance,
Serializable id,
EntityPersister persister,
Interceptor interceptor,
EventSource session) |
Constructor and Description |
---|
CacheEntry(Object[] state,
EntityPersister persister,
boolean unfetched,
Object version,
SessionImplementor session,
Object owner) |
Modifier and Type | Class and Description |
---|---|
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.
|
Modifier and Type | Method and Description |
---|---|
SessionFactory |
Configuration.buildSessionFactory()
Create a
SessionFactory using the properties and mappings in this configuration. |
Settings |
Configuration.buildSettings(Properties props) |
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) |
Modifier and Type | Class and Description |
---|---|
class |
ValidationFailure
Thrown from Validatable.validate() when an invariant
was violated.
|
Modifier and Type | Method and Description |
---|---|
int |
Session.delete(String query)
Deprecated.
consider using HQL delete statements
|
int |
Session.delete(String query,
Object[] values,
Type[] types)
Deprecated.
consider using HQL delete statements
|
int |
Session.delete(String query,
Object value,
Type type)
Deprecated.
consider using HQL delete statements
|
Collection |
Session.filter(Object collection,
String filter)
Deprecated.
|
Collection |
Session.filter(Object collection,
String filter,
Object[] values,
Type[] types)
Deprecated.
use
Session.createFilter(Object, String) .setXYZ.Query.list() |
Collection |
Session.filter(Object collection,
String filter,
Object value,
Type type)
Deprecated.
use
Session.createFilter(Object, String) .setXYZ.Query.list() |
List |
Session.find(String query)
Deprecated.
|
List |
Session.find(String query,
Object[] values,
Type[] types)
Deprecated.
|
List |
Session.find(String query,
Object value,
Type type)
Deprecated.
|
Iterator |
Session.iterate(String query)
Deprecated.
|
Iterator |
Session.iterate(String query,
Object[] values,
Type[] types)
Deprecated.
|
Iterator |
Session.iterate(String query,
Object value,
Type type)
Deprecated.
|
void |
Session.save(Object object,
Serializable id)
Deprecated.
declare identifier properties for all classes
|
void |
Session.save(String entityName,
Object object,
Serializable id)
Deprecated.
declare identifier properties for all classes
|
Object |
Session.saveOrUpdateCopy(Object object)
Deprecated.
|
Object |
Session.saveOrUpdateCopy(Object object,
Serializable id)
Deprecated.
with no replacement
|
Object |
Session.saveOrUpdateCopy(String entityName,
Object object)
Deprecated.
|
Object |
Session.saveOrUpdateCopy(String entityName,
Object object,
Serializable id)
Deprecated.
with no replacement
|
void |
Session.update(Object object,
Serializable id)
Deprecated.
declare identifier properties for all classes
|
void |
Session.update(String entityName,
Object object,
Serializable id)
Deprecated.
declare identifier properties for all classes
|
Modifier and Type | Method and Description |
---|---|
void |
PersistentCollection.afterRowInsert(CollectionPersister persister,
Object entry,
int i)
Called after inserting a row, to fetch the natively generated id
|
void |
AbstractPersistentCollection.afterRowInsert(CollectionPersister persister,
Object entry,
int i)
Called after inserting a row, to fetch the natively generated id
|
void |
PersistentIdentifierBag.afterRowInsert(CollectionPersister persister,
Object entry,
int i) |
Serializable |
PersistentCollection.disassemble(CollectionPersister persister)
Disassemble the collection, ready for the cache
|
Serializable |
PersistentListElementHolder.disassemble(CollectionPersister persister) |
Serializable |
PersistentArrayHolder.disassemble(CollectionPersister persister) |
Serializable |
PersistentElementHolder.disassemble(CollectionPersister persister) |
Serializable |
PersistentIdentifierBag.disassemble(CollectionPersister persister) |
Serializable |
PersistentSet.disassemble(CollectionPersister persister) |
Serializable |
PersistentMap.disassemble(CollectionPersister persister) |
Serializable |
PersistentList.disassemble(CollectionPersister persister) |
Serializable |
PersistentMapElementHolder.disassemble(CollectionPersister persister) |
Serializable |
PersistentBag.disassemble(CollectionPersister persister) |
boolean |
PersistentCollection.equalsSnapshot(CollectionPersister persister)
Does the current state exactly match the snapshot?
|
boolean |
PersistentArrayHolder.equalsSnapshot(CollectionPersister persister) |
boolean |
PersistentElementHolder.equalsSnapshot(CollectionPersister persister) |
boolean |
PersistentIdentifierBag.equalsSnapshot(CollectionPersister persister) |
boolean |
PersistentIndexedElementHolder.equalsSnapshot(CollectionPersister persister) |
boolean |
PersistentSet.equalsSnapshot(CollectionPersister persister) |
boolean |
PersistentMap.equalsSnapshot(CollectionPersister persister) |
boolean |
PersistentList.equalsSnapshot(CollectionPersister persister) |
boolean |
PersistentBag.equalsSnapshot(CollectionPersister persister) |
void |
PersistentCollection.forceInitialization()
To be called internally by the session, forcing
immediate initialization.
|
void |
AbstractPersistentCollection.forceInitialization()
To be called internally by the session, forcing
immediate initialization.
|
Iterator |
PersistentCollection.getDeletes(CollectionPersister persister,
boolean indexIsFormula)
Get all the elements that need deleting
|
Iterator |
PersistentArrayHolder.getDeletes(CollectionPersister persister,
boolean indexIsFormula) |
Iterator |
PersistentElementHolder.getDeletes(CollectionPersister persister,
boolean indexIsFormula) |
Iterator |
PersistentIdentifierBag.getDeletes(CollectionPersister persister,
boolean indexIsFormula) |
Iterator |
PersistentIndexedElementHolder.getDeletes(CollectionPersister persister,
boolean indexIsFormula) |
Iterator |
PersistentSet.getDeletes(CollectionPersister persister,
boolean indexIsFormula) |
Iterator |
PersistentMap.getDeletes(CollectionPersister persister,
boolean indexIsFormula) |
Iterator |
PersistentList.getDeletes(CollectionPersister persister,
boolean indexIsFormula) |
Iterator |
PersistentBag.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 |
PersistentCollection.getOrphans(Serializable snapshot,
String entityName)
get all "orphaned" elements
|
abstract Collection |
AbstractPersistentCollection.getOrphans(Serializable snapshot,
String entityName)
get all "orphaned" elements
|
Collection |
PersistentArrayHolder.getOrphans(Serializable snapshot,
String entityName) |
Collection |
PersistentElementHolder.getOrphans(Serializable snapshot,
String entityName) |
Collection |
PersistentIdentifierBag.getOrphans(Serializable snapshot,
String entityName) |
Collection |
PersistentIndexedElementHolder.getOrphans(Serializable snapshot,
String entityName) |
Collection |
PersistentSet.getOrphans(Serializable snapshot,
String entityName) |
Collection |
PersistentMap.getOrphans(Serializable snapshot,
String entityName) |
Collection |
PersistentList.getOrphans(Serializable snapshot,
String entityName) |
Collection |
PersistentBag.getOrphans(Serializable snapshot,
String entityName) |
Serializable |
PersistentCollection.getSnapshot(CollectionPersister persister)
Return a new snapshot of the current state of the collection
|
Serializable |
PersistentArrayHolder.getSnapshot(CollectionPersister persister) |
Serializable |
PersistentElementHolder.getSnapshot(CollectionPersister persister) |
Serializable |
PersistentIdentifierBag.getSnapshot(CollectionPersister persister) |
Serializable |
PersistentIndexedElementHolder.getSnapshot(CollectionPersister persister) |
Serializable |
PersistentSet.getSnapshot(CollectionPersister persister) |
Serializable |
PersistentMap.getSnapshot(CollectionPersister persister) |
Serializable |
PersistentList.getSnapshot(CollectionPersister persister) |
Serializable |
PersistentBag.getSnapshot(CollectionPersister persister) |
void |
PersistentCollection.initializeFromCache(CollectionPersister persister,
Serializable disassembled,
Object owner)
Read the state of the collection from a disassembled cached value
|
void |
PersistentListElementHolder.initializeFromCache(CollectionPersister persister,
Serializable disassembled,
Object owner) |
void |
PersistentArrayHolder.initializeFromCache(CollectionPersister persister,
Serializable disassembled,
Object owner) |
void |
PersistentElementHolder.initializeFromCache(CollectionPersister persister,
Serializable disassembled,
Object owner) |
void |
PersistentIdentifierBag.initializeFromCache(CollectionPersister persister,
Serializable disassembled,
Object owner) |
void |
PersistentSet.initializeFromCache(CollectionPersister persister,
Serializable disassembled,
Object owner) |
void |
PersistentMap.initializeFromCache(CollectionPersister persister,
Serializable disassembled,
Object owner) |
void |
PersistentList.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) |
boolean |
PersistentCollection.needsInserting(Object entry,
int i,
Type elemType)
Do we need to insert this element?
|
boolean |
PersistentArrayHolder.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 |
PersistentIndexedElementHolder.needsInserting(Object entry,
int i,
Type elementType) |
boolean |
PersistentSet.needsInserting(Object entry,
int i,
Type elemType) |
boolean |
PersistentMap.needsInserting(Object entry,
int i,
Type elemType) |
boolean |
PersistentList.needsInserting(Object entry,
int i,
Type elemType) |
boolean |
PersistentBag.needsInserting(Object entry,
int i,
Type elemType) |
boolean |
PersistentCollection.needsUpdating(Object entry,
int i,
Type elemType)
Do we need to update this element?
|
boolean |
PersistentArrayHolder.needsUpdating(Object entry,
int i,
Type elemType) |
boolean |
PersistentElementHolder.needsUpdating(Object entry,
int i,
Type elementType) |
boolean |
PersistentIdentifierBag.needsUpdating(Object entry,
int i,
Type elemType) |
boolean |
PersistentIndexedElementHolder.needsUpdating(Object entry,
int i,
Type elementType) |
boolean |
PersistentMap.needsUpdating(Object entry,
int i,
Type elemType) |
boolean |
PersistentList.needsUpdating(Object entry,
int i,
Type elemType) |
void |
PersistentCollection.preInsert(CollectionPersister persister)
Called before inserting rows, to ensure that any surrogate keys
are fully generated
|
void |
AbstractPersistentCollection.preInsert(CollectionPersister persister)
Called before inserting rows, to ensure that any surrogate keys
are fully generated
|
void |
PersistentIdentifierBag.preInsert(CollectionPersister persister) |
Object |
PersistentCollection.readFrom(ResultSet rs,
CollectionPersister role,
CollectionAliases descriptor,
Object owner)
Read a row from the JDBC result set
|
Object |
PersistentArrayHolder.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 |
PersistentIndexedElementHolder.readFrom(ResultSet rs,
CollectionPersister persister,
CollectionAliases descriptor,
Object owner) |
Object |
PersistentSet.readFrom(ResultSet rs,
CollectionPersister persister,
CollectionAliases descriptor,
Object owner) |
Object |
PersistentMap.readFrom(ResultSet rs,
CollectionPersister persister,
CollectionAliases descriptor,
Object owner) |
Object |
PersistentList.readFrom(ResultSet rs,
CollectionPersister persister,
CollectionAliases descriptor,
Object owner) |
Object |
PersistentBag.readFrom(ResultSet rs,
CollectionPersister persister,
CollectionAliases descriptor,
Object owner) |
boolean |
PersistentCollection.setCurrentSession(SessionImplementor session)
Associate the collection with the given session.
|
boolean |
AbstractPersistentCollection.setCurrentSession(SessionImplementor session)
Associate the collection with the given session.
|
protected Serializable |
PersistentSortedMap.snapshot(BasicCollectionPersister persister,
EntityMode entityMode) |
protected Serializable |
PersistentSortedSet.snapshot(BasicCollectionPersister persister,
EntityMode entityMode) |
Constructor and Description |
---|
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) |
Modifier and Type | Method and Description |
---|---|
void |
ProxoolConnectionProvider.close()
Release all resources held by this provider.
|
void |
ConnectionProvider.close()
Release all resources held by this provider.
|
void |
ProxoolConnectionProvider.configure(Properties props)
Initialize the connection provider from given properties.
|
void |
C3P0ConnectionProvider.configure(Properties props)
Initialize the connection provider from given properties.
|
void |
DriverManagerConnectionProvider.configure(Properties props) |
void |
UserSuppliedConnectionProvider.configure(Properties props) |
void |
DatasourceConnectionProvider.configure(Properties props) |
void |
ConnectionProvider.configure(Properties props)
Initialize the connection provider from given properties.
|
static ConnectionProvider |
ConnectionProviderFactory.newConnectionProvider()
Instantiate a ConnectionProvider using System properties.
|
static ConnectionProvider |
ConnectionProviderFactory.newConnectionProvider(Properties properties)
Instantiate a ConnectionProvider using given properties.
|
static ConnectionProvider |
ConnectionProviderFactory.newConnectionProvider(Properties properties,
Map connectionProviderInjectionData)
Create a connection provider based on the given information.
|
Modifier and Type | Method and Description |
---|---|
Session |
JTASessionContext.currentSession()
Retrieve the current session according to the scoping defined
by this implementation.
|
Session |
ThreadLocalSessionContext.currentSession()
Retrieve the current session according to the scoping defined
by this implementation.
|
Session |
CurrentSessionContext.currentSession()
Retrieve the current session according to the scoping defined
by this implementation.
|
Modifier and Type | Method and Description |
---|---|
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,
StringBuffer buf) |
protected void |
Example.appendPropertyCondition(String propertyName,
Object propertyValue,
Criteria criteria,
CriteriaQuery cq,
StringBuffer buf) |
DetachedCriteria |
DetachedCriteria.createAlias(String associationPath,
String alias) |
DetachedCriteria |
DetachedCriteria.createAlias(String associationPath,
String alias,
int joinType) |
DetachedCriteria |
DetachedCriteria.createAlias(String associationPath,
String alias,
int joinType,
Criterion withClause) |
DetachedCriteria |
DetachedCriteria.createCriteria(String associationPath) |
DetachedCriteria |
DetachedCriteria.createCriteria(String associationPath,
int joinType) |
DetachedCriteria |
DetachedCriteria.createCriteria(String associationPath,
String alias) |
DetachedCriteria |
DetachedCriteria.createCriteria(String associationPath,
String alias,
int joinType) |
DetachedCriteria |
DetachedCriteria.createCriteria(String associationPath,
String alias,
int 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[] |
LogicalExpression.getTypedValues(Criteria criteria,
CriteriaQuery criteriaQuery) |
TypedValue[] |
LikeExpression.getTypedValues(Criteria criteria,
CriteriaQuery criteriaQuery) |
TypedValue[] |
SimpleSubqueryExpression.getTypedValues(Criteria criteria,
CriteriaQuery criteriaQuery) |
TypedValue[] |
InExpression.getTypedValues(Criteria criteria,
CriteriaQuery criteriaQuery) |
TypedValue[] |
IdentifierEqExpression.getTypedValues(Criteria criteria,
CriteriaQuery criteriaQuery) |
TypedValue[] |
SizeExpression.getTypedValues(Criteria criteria,
CriteriaQuery criteriaQuery) |
TypedValue[] |
NaturalIdentifier.getTypedValues(Criteria criteria,
CriteriaQuery criteriaQuery) |
TypedValue[] |
NotExpression.getTypedValues(Criteria criteria,
CriteriaQuery criteriaQuery) |
TypedValue[] |
NullExpression.getTypedValues(Criteria criteria,
CriteriaQuery criteriaQuery) |
TypedValue[] |
SimpleExpression.getTypedValues(Criteria criteria,
CriteriaQuery criteriaQuery) |
TypedValue[] |
Junction.getTypedValues(Criteria crit,
CriteriaQuery criteriaQuery) |
TypedValue[] |
SubqueryExpression.getTypedValues(Criteria criteria,
CriteriaQuery criteriaQuery) |
TypedValue[] |
Criterion.getTypedValues(Criteria criteria,
CriteriaQuery criteriaQuery)
Return typed values for all parameters in the rendered SQL fragment
|
TypedValue[] |
NotNullExpression.getTypedValues(Criteria criteria,
CriteriaQuery criteriaQuery) |
TypedValue[] |
Example.getTypedValues(Criteria criteria,
CriteriaQuery criteriaQuery) |
TypedValue[] |
PropertyExpression.getTypedValues(Criteria criteria,
CriteriaQuery criteriaQuery) |
TypedValue[] |
SQLCriterion.getTypedValues(Criteria criteria,
CriteriaQuery criteriaQuery) |
TypedValue[] |
BetweenExpression.getTypedValues(Criteria criteria,
CriteriaQuery criteriaQuery) |
TypedValue[] |
AbstractEmptinessExpression.getTypedValues(Criteria criteria,
CriteriaQuery criteriaQuery) |
TypedValue[] |
IlikeExpression.getTypedValues(Criteria criteria,
CriteriaQuery criteriaQuery) |
Type[] |
AggregateProjection.getTypes(Criteria criteria,
CriteriaQuery criteriaQuery)
Types returned by the rendered SQL
fragment . |
Type[] |
IdentifierProjection.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[] |
PropertyProjection.getTypes(Criteria criteria,
CriteriaQuery criteriaQuery) |
Type[] |
ProjectionList.getTypes(Criteria criteria,
CriteriaQuery criteriaQuery) |
Type[] |
RowCountProjection.getTypes(Criteria criteria,
CriteriaQuery criteriaQuery) |
Type[] |
Distinct.getTypes(Criteria criteria,
CriteriaQuery criteriaQuery) |
Type[] |
AliasedProjection.getTypes(Criteria criteria,
CriteriaQuery criteriaQuery) |
Type[] |
Projection.getTypes(String alias,
Criteria criteria,
CriteriaQuery criteriaQuery)
Get the return types for a particular user-visible alias.
|
Type[] |
SimpleProjection.getTypes(String alias,
Criteria criteria,
CriteriaQuery criteriaQuery) |
Type[] |
Distinct.getTypes(String alias,
Criteria criteria,
CriteriaQuery criteriaQuery) |
Type[] |
AliasedProjection.getTypes(String alias,
Criteria criteria,
CriteriaQuery criteriaQuery) |
Type |
CriteriaQuery.getTypeUsingProjection(Criteria criteria,
String propertyPath)
Get the type of a property path
|
DetachedCriteria |
DetachedCriteria.setFetchMode(String associationPath,
FetchMode mode) |
String |
IdentifierProjection.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 |
SimpleProjection.toGroupSqlString(Criteria criteria,
CriteriaQuery criteriaQuery) |
String |
PropertyProjection.toGroupSqlString(Criteria criteria,
CriteriaQuery criteriaQuery) |
String |
ProjectionList.toGroupSqlString(Criteria criteria,
CriteriaQuery criteriaQuery) |
String |
Distinct.toGroupSqlString(Criteria criteria,
CriteriaQuery criteriaQuery) |
String |
AliasedProjection.toGroupSqlString(Criteria criteria,
CriteriaQuery criteriaQuery) |
String |
LogicalExpression.toSqlString(Criteria criteria,
CriteriaQuery criteriaQuery) |
String |
LikeExpression.toSqlString(Criteria criteria,
CriteriaQuery criteriaQuery) |
String |
InExpression.toSqlString(Criteria criteria,
CriteriaQuery criteriaQuery) |
String |
IdentifierEqExpression.toSqlString(Criteria criteria,
CriteriaQuery criteriaQuery) |
String |
SizeExpression.toSqlString(Criteria criteria,
CriteriaQuery criteriaQuery) |
String |
NaturalIdentifier.toSqlString(Criteria criteria,
CriteriaQuery criteriaQuery) |
String |
NotExpression.toSqlString(Criteria criteria,
CriteriaQuery criteriaQuery) |
String |
NullExpression.toSqlString(Criteria criteria,
CriteriaQuery criteriaQuery) |
String |
SimpleExpression.toSqlString(Criteria criteria,
CriteriaQuery criteriaQuery) |
String |
Junction.toSqlString(Criteria crit,
CriteriaQuery criteriaQuery) |
String |
SubqueryExpression.toSqlString(Criteria criteria,
CriteriaQuery criteriaQuery) |
String |
Criterion.toSqlString(Criteria criteria,
CriteriaQuery criteriaQuery)
Render the SQL fragment
|
String |
NotNullExpression.toSqlString(Criteria criteria,
CriteriaQuery criteriaQuery) |
String |
Example.toSqlString(Criteria criteria,
CriteriaQuery criteriaQuery) |
String |
PropertyExpression.toSqlString(Criteria criteria,
CriteriaQuery criteriaQuery) |
String |
SQLCriterion.toSqlString(Criteria criteria,
CriteriaQuery criteriaQuery) |
String |
BetweenExpression.toSqlString(Criteria criteria,
CriteriaQuery criteriaQuery) |
String |
AbstractEmptinessExpression.toSqlString(Criteria criteria,
CriteriaQuery criteriaQuery) |
String |
IlikeExpression.toSqlString(Criteria criteria,
CriteriaQuery criteriaQuery) |
String |
Order.toSqlString(Criteria criteria,
CriteriaQuery criteriaQuery)
Render the SQL fragment
|
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 |
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 |
PropertyProjection.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 |
Distinct.toSqlString(Criteria criteria,
int position,
CriteriaQuery criteriaQuery) |
String |
AliasedProjection.toSqlString(Criteria criteria,
int position,
CriteriaQuery criteriaQuery) |
Modifier and Type | Method and Description |
---|---|
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)
|
String |
Dialect.getHibernateTypeName(int code,
int length,
int precision,
int scale)
|
String |
Dialect.getTypeName(int code)
Get the name of the database type associated with the given
Types typecode. |
String |
TeradataDialect.getTypeName(int code,
int length,
int precision,
int scale)
Get the name of the database type associated with the given
java.sql.Types typecode.
|
String |
Dialect.getTypeName(int code,
int length,
int precision,
int scale)
Get the name of the database type associated with the given
Types typecode with the given storage specification
parameters. |
Modifier and Type | Method and Description |
---|---|
static Dialect |
DialectFactory.buildDialect(Properties properties,
Connection connection)
Builds an appropriate Dialect instance.
|
Modifier and Type | Method and Description |
---|---|
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. |
javax.persistence.PersistenceException |
AbstractEntityManagerImpl.wrapLockException(HibernateException e,
LockOptions lockOptions) |
Modifier and Type | Method and Description |
---|---|
Settings |
Ejb3Configuration.buildSettings() |
Ejb3Configuration |
Ejb3Configuration.configure(String resource) |
Modifier and Type | Method and Description |
---|---|
void |
InjectedDataSourceConnectionProvider.configure(Properties props) |
Modifier and Type | Method and Description |
---|---|
void |
JoinableCMTTransaction.begin() |
void |
JoinableCMTTransaction.commit() |
Transaction |
JoinableCMTTransactionFactory.createTransaction(JDBCContext jdbcContext,
TransactionFactory.Context transactionContext) |
Modifier and Type | Method and Description |
---|---|
CollectionEntry |
PersistenceContext.addInitializedCollection(CollectionPersister persister,
PersistentCollection collection,
Serializable id)
add a collection we just pulled out of the cache (does not need initializing)
|
CollectionEntry |
StatefulPersistenceContext.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 |
StatefulPersistenceContext.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 |
StatefulPersistenceContext.addNewCollection(CollectionPersister persister,
PersistentCollection collection)
Add a new collection (ie.
|
void |
SessionImplementor.applyNonFlushedChanges(NonFlushedChanges nonFlushedChanges)
Apply non-flushed changes from a different session to this session.
|
static int |
ParameterBinder.bindNamedParameters(PreparedStatement ps,
Map namedParams,
int start,
ParameterBinder.NamedParameterSource source,
SessionImplementor session) |
static int |
ParameterBinder.bindNamedParameters(PreparedStatement ps,
QueryParameters queryParameters,
int start,
ParameterBinder.NamedParameterSource source,
SessionImplementor session) |
static int |
ParameterBinder.bindPositionalParameters(PreparedStatement st,
Object[] values,
Type[] types,
int start,
SessionImplementor session) |
static int |
ParameterBinder.bindPositionalParameters(PreparedStatement st,
QueryParameters queryParameters,
int start,
SessionImplementor session) |
static int |
ParameterBinder.bindQueryParameters(PreparedStatement st,
QueryParameters queryParameters,
int start,
ParameterBinder.NamedParameterSource source,
SessionImplementor session) |
void |
Cascade.cascade(EntityPersister persister,
Object parent)
Cascade an action from the parent entity instance to all its children.
|
void |
Cascade.cascade(EntityPersister persister,
Object parent,
Object anything)
Cascade an action from the parent entity instance to all its children.
|
abstract void |
CascadingAction.cascade(EventSource session,
Object child,
String entityName,
Object anything,
boolean isCascadeDeleteEnabled)
Cascade the action to the child object.
|
void |
Nullability.checkNullability(Object[] values,
EntityPersister persister,
boolean isUpdate)
Check nullability of the class persister properties
|
void |
PersistenceContext.checkUniqueness(EntityKey key,
Object object)
Attempts to check whether the given key represents an entity already loaded within the
current session.
|
void |
StatefulPersistenceContext.checkUniqueness(EntityKey key,
Object object)
Attempts to check whether the given key represents an entity already loaded within the
current session.
|
Serializable |
TransactionHelper.doWorkInNewTransaction(SessionImplementor session)
Suspend the current transaction and perform work in a new transaction
|
void |
ActionQueue.executeActions()
Perform all currently queued actions.
|
void |
ActionQueue.executeInserts()
Perform all currently queued entity-insertion actions.
|
int |
SessionImplementor.executeNativeUpdate(NativeSQLQuerySpecification specification,
QueryParameters queryParameters)
Execute a native SQL update or delete query
|
int |
SessionImplementor.executeUpdate(String query,
QueryParameters queryParameters)
Execute a HQL update or delete query
|
Object[] |
PersistenceContext.getDatabaseSnapshot(Serializable id,
EntityPersister persister)
Get the current state of the entity as known to the underlying
database, or null if there is no corresponding row
|
Object[] |
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.
|
EntityPersister |
SessionImplementor.getEntityPersister(String entityName,
Object object)
Get the EntityPersister for any instance
|
Object |
SessionImplementor.getEntityUsingInterceptor(EntityKey key)
Get the entity instance associated with the given Key,
calling the Interceptor if necessary
|
Object[] |
PersistenceContext.getNaturalIdSnapshot(Serializable id,
EntityPersister persister)
Get the values of the natural id fields as known to the underlying
database, or null if the entity has no natural id or there is no
corresponding row.
|
Object[] |
StatefulPersistenceContext.getNaturalIdSnapshot(Serializable id,
EntityPersister persister) |
NonFlushedChanges |
SessionImplementor.getNonFlushedChanges()
Return changes to this session that have not been flushed yet.
|
Collection |
CollectionEntry.getOrphans(String entityName,
PersistentCollection collection)
Get the collection orphans (entities which were removed from the collection)
|
QueryCache |
SessionFactoryImplementor.getQueryCache(String regionName)
Get a particular named query cache, or the default cache
|
String[] |
SessionFactoryImplementor.getReturnAliases(String queryString)
Get the return aliases of a query
|
Type[] |
SessionFactoryImplementor.getReturnTypes(String queryString)
Get the return types of a query
|
String |
SessionImplementor.guessEntityName(Object entity)
The guessed entity name for an entity not in an association
|
Object |
SessionImplementor.immediateLoad(String entityName,
Serializable id)
Load an instance immediately.
|
void |
SessionImplementor.initializeCollection(PersistentCollection collection,
boolean writing)
Initialize the collection (if not already initialized)
|
static void |
TwoPhaseLoad.initializeEntity(Object entity,
boolean readOnly,
SessionImplementor session,
PreLoadEvent preLoadEvent,
PostLoadEvent postLoadEvent)
Perform the second step of 2-phase load.
|
void |
PersistenceContext.initializeNonLazyCollections()
Force initialization of all non-lazy collections encountered during
the current two-phase load (actually, this is a no-op, unless this
is the "outermost" load)
|
void |
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)
|
Object |
SessionImplementor.instantiate(String entityName,
Serializable id)
Instantiate the entity class, initializing with the given identifier
|
Object |
SessionImplementor.internalLoad(String entityName,
Serializable id,
boolean eager,
boolean nullable)
Load an instance without checking if it was deleted.
|
static boolean |
ForeignKeys.isNotTransient(String entityName,
Object entity,
Boolean assumed,
SessionImplementor session)
Is this instance persistent or detached?
If assumed is non-null, don't hit the database to make the
determination, instead assume that value; the client code must be
prepared to "recover" in the case that this assumed result is incorrect.
|
static boolean |
ForeignKeys.isTransient(String entityName,
Object entity,
Boolean assumed,
SessionImplementor session)
Is this instance, which we know is not persistent, actually transient?
If assumed is non-null, don't hit the database to make the
determination, instead assume that value; the client code must be
prepared to "recover" in the case that this assumed result is incorrect.
|
Iterator |
SessionImplementor.iterate(String query,
QueryParameters queryParameters)
Execute an iterate() query
|
Iterator |
SessionImplementor.iterateFilter(Object collection,
String filter,
QueryParameters queryParameters)
Iterate a filter
|
List |
SessionImplementor.list(NativeSQLQuerySpecification spec,
QueryParameters queryParameters)
Execute a native SQL query, and return the results as a fully built list.
|
List |
SessionImplementor.list(String query,
QueryParameters queryParameters)
Execute a find() query
|
List |
SessionImplementor.listCustomQuery(CustomQuery customQuery,
QueryParameters queryParameters)
Execute an SQL Query
|
List |
SessionImplementor.listFilter(Object collection,
String filter,
QueryParameters queryParameters)
Execute a filter
|
Object |
PersistenceContext.narrowProxy(Object proxy,
EntityPersister persister,
EntityKey key,
Object object)
If the existing proxy is insufficiently "narrow" (derived), instantiate a new proxy
and overwrite the registration of the old one.
|
Object |
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
|
Session |
SessionFactoryImplementor.openSession(Connection connection,
boolean flushBeforeCompletionEnabled,
boolean autoCloseSessionEnabled,
ConnectionReleaseMode connectionReleaseMode)
Open a session conforming to the given parameters.
|
Session |
SessionFactoryImplementor.openTemporarySession()
Get a nontransactional "current" session for Hibernate EntityManager
|
void |
CollectionEntry.postFlush(PersistentCollection collection)
Called after a successful flush
|
static void |
TwoPhaseLoad.postHydrate(EntityPersister persister,
Serializable id,
Object[] values,
Object rowId,
Object object,
LockMode lockMode,
boolean lazyPropertiesAreUnfetched,
SessionImplementor session)
Register the "hydrated" state of an entity instance, after the first step of 2-phase loading.
|
void |
CollectionEntry.postInitialize(PersistentCollection collection) |
void |
CollectionEntry.preFlush(PersistentCollection collection) |
void |
ActionQueue.prepareActions()
Prepares the internal action queues for execution.
|
static void |
Collections.processReachableCollection(PersistentCollection collection,
CollectionType type,
Object entity,
SessionImplementor session)
Initialize the role of the collection.
|
static void |
Collections.processUnreachableCollection(PersistentCollection coll,
SessionImplementor session)
record the fact that this collection was dereferenced
|
Object |
PersistenceContext.proxyFor(EntityPersister persister,
EntityKey key,
Object impl)
Return the existing proxy associated with the given EntityKey, or the
third argument (the entity associated with the key) if no proxy exists.
|
Object |
StatefulPersistenceContext.proxyFor(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.
|
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.
|
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 |
StatefulPersistenceContext.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.
|
Object |
StatefulPersistenceContext.unproxyAndReassociate(Object maybeProxy)
Possibly unproxy the given reference and reassociate it with the current session.
|
Modifier and Type | Method and Description |
---|---|
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) |
Modifier and Type | Class and Description |
---|---|
class |
NullSynchronizationException
TODO : javadoc
|
Modifier and Type | Method and Description |
---|---|
void |
Isolater.JtaDelegate.delegateWork(IsolatedWork work,
boolean transacted) |
void |
Isolater.JdbcDelegate.delegateWork(IsolatedWork work,
boolean transacted) |
static void |
Isolater.doIsolatedWork(IsolatedWork work,
SessionImplementor session)
Ensures that all processing actually performed by the given work will
occur on a seperate transaction.
|
static void |
Isolater.doNonTransactedWork(IsolatedWork work,
SessionImplementor session)
Ensures that all processing actually performed by the given work will
occur outside of a transaction.
|
void |
IsolatedWork.doWork(Connection connection)
Perform the actual work to be done.
|
Modifier and Type | Method and Description |
---|---|
String |
AuditReader.getEntityName(Object primaryKey,
Number revision,
Object entity) |
Modifier and Type | Method and Description |
---|---|
Object |
RevisionTypeType.assemble(Serializable cached,
Object owner) |
Object |
RevisionTypeType.deepCopy(Object value) |
Serializable |
RevisionTypeType.disassemble(Object value) |
boolean |
RevisionTypeType.equals(Object x,
Object y) |
int |
RevisionTypeType.hashCode(Object x) |
RevisionType |
RevisionTypeType.nullSafeGet(ResultSet resultSet,
String[] names,
Object owner) |
void |
RevisionTypeType.nullSafeSet(PreparedStatement preparedStatement,
Object value,
int index) |
Object |
RevisionTypeType.replace(Object original,
Object target,
Object owner) |
Modifier and Type | Method and Description |
---|---|
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) |
Modifier and Type | Class and Description |
---|---|
class |
AuditException |
class |
NotAuditedException |
class |
RevisionDoesNotExistException |
Modifier and Type | Method and Description |
---|---|
String |
AuditReaderImpl.getEntityName(Object primaryKey,
Number revision,
Object entity) |
Modifier and Type | Method and Description |
---|---|
void |
EventSource.forceFlush(EntityEntry e)
Force an immediate flush
|
Object |
EventSource.instantiate(EntityPersister persister,
Serializable id)
Instantiate an entity instance, using either an interceptor,
or the given persister
|
void |
EventSource.merge(String entityName,
Object object,
Map copiedAlready)
Cascade merge an entity instance
|
void |
AutoFlushEventListener.onAutoFlush(AutoFlushEvent event)
Handle the given auto-flush event.
|
void |
DeleteEventListener.onDelete(DeleteEvent event)
Handle the given delete event.
|
void |
DeleteEventListener.onDelete(DeleteEvent event,
Set transientEntities) |
void |
DirtyCheckEventListener.onDirtyCheck(DirtyCheckEvent event)
Handle the given dirty-check event.
|
void |
EvictEventListener.onEvict(EvictEvent event)
Handle the given evict event.
|
void |
FlushEventListener.onFlush(FlushEvent event)
Handle the given flush event.
|
void |
FlushEntityEventListener.onFlushEntity(FlushEntityEvent event) |
void |
InitializeCollectionEventListener.onInitializeCollection(InitializeCollectionEvent event) |
void |
LoadEventListener.onLoad(LoadEvent event,
LoadEventListener.LoadType loadType)
Handle the given load event.
|
void |
LockEventListener.onLock(LockEvent event)
Handle the given lock event.
|
void |
MergeEventListener.onMerge(MergeEvent event)
Handle the given merge event.
|
void |
MergeEventListener.onMerge(MergeEvent event,
Map copiedAlready)
Handle the given merge event.
|
void |
PersistEventListener.onPersist(PersistEvent event)
Handle the given create event.
|
void |
PersistEventListener.onPersist(PersistEvent event,
Map createdAlready)
Handle the given create event.
|
void |
RefreshEventListener.onRefresh(RefreshEvent event)
Handle the given refresh event.
|
void |
RefreshEventListener.onRefresh(RefreshEvent event,
Map refreshedAlready) |
void |
ReplicateEventListener.onReplicate(ReplicateEvent event)
Handle the given replicate event.
|
void |
SaveOrUpdateEventListener.onSaveOrUpdate(SaveOrUpdateEvent event)
Handle the given update event.
|
void |
EventSource.persist(String entityName,
Object object,
Map createdAlready)
Cascade persist an entity instance
|
void |
EventSource.refresh(Object object,
Map refreshedAlready)
Cascade refesh an entity instance
|
void |
EventSource.saveOrUpdateCopy(String entityName,
Object object,
Map copiedAlready)
Cascade copy an entity instance
|
Modifier and Type | Method and Description |
---|---|
protected void |
DefaultDeleteEventListener.cascadeAfterDelete(EventSource session,
EntityPersister persister,
Object entity,
Set transientEntities) |
protected void |
DefaultMergeEventListener.cascadeAfterSave(EventSource source,
EntityPersister persister,
Object entity,
Object anything)
Cascade behavior is redefined by this subclass, disable superclass behavior
|
protected void |
DefaultDeleteEventListener.cascadeBeforeDelete(EventSource session,
EntityPersister persister,
Object entity,
EntityEntry entityEntry,
Set transientEntities) |
protected void |
DefaultMergeEventListener.cascadeBeforeSave(EventSource source,
EntityPersister persister,
Object entity,
Object anything)
Cascade behavior is redefined by this subclass, disable superclass behavior
|
void |
DefaultFlushEntityEventListener.checkId(Object object,
EntityPersister persister,
Serializable id,
EntityMode entityMode,
SessionImplementor session)
make sure user didn't mangle the id
|
protected void |
DefaultFlushEntityEventListener.dirtyCheck(FlushEntityEvent event)
Perform a dirty check, and attach the results to the event
|
protected void |
DefaultEvictEventListener.doEvict(Object object,
EntityKey key,
EntityPersister persister,
EventSource session) |
protected Serializable |
DefaultSaveOrUpdateEventListener.entityIsPersistent(SaveOrUpdateEvent event) |
protected void |
DefaultPersistEventListener.entityIsTransient(PersistEvent event,
Map createCache)
Handle the given create event.
|
protected void |
AbstractFlushingEventListener.flushEverythingToExecutions(FlushEvent event)
Coordinates the processing necessary to get things ready for executions
as db calls by preping the session caches and moving the appropriate
entities and collections to their respective execution queues.
|
protected Serializable |
DefaultUpdateEventListener.getUpdateId(Object entity,
EntityPersister persister,
Serializable requestedId,
SessionImplementor session)
If the user specified an id, assign it to the instance and use that,
otherwise use the id already assigned to the instance
|
protected boolean |
DefaultFlushEntityEventListener.isUpdateNecessary(FlushEntityEvent event)
Performs all necessary checking to determine if an entity needs an SQL update
to synchronize its state to the database.
|
protected Object |
DefaultLoadEventListener.loadFromSessionCache(LoadEvent event,
EntityKey keyToLoad,
LoadEventListener.LoadType options)
Attempts to locate the entity in the session-level cache.
|
void |
DefaultAutoFlushEventListener.onAutoFlush(AutoFlushEvent event)
Handle the given auto-flush event.
|
void |
DefaultDeleteEventListener.onDelete(DeleteEvent event)
Handle the given delete event.
|
void |
DefaultDeleteEventListener.onDelete(DeleteEvent event,
Set transientEntities)
Handle the given delete event.
|
void |
DefaultDirtyCheckEventListener.onDirtyCheck(DirtyCheckEvent event)
Handle the given dirty-check event.
|
void |
DefaultEvictEventListener.onEvict(EvictEvent event)
Handle the given evict event.
|
void |
DefaultFlushEventListener.onFlush(FlushEvent event)
Handle the given flush event.
|
void |
DefaultFlushEntityEventListener.onFlushEntity(FlushEntityEvent event)
Flushes a single entity's state to the database, by scheduling
an update action, if necessary
|
void |
DefaultInitializeCollectionEventListener.onInitializeCollection(InitializeCollectionEvent event)
called by a collection that wants to initialize itself
|
void |
DefaultLoadEventListener.onLoad(LoadEvent event,
LoadEventListener.LoadType loadType)
Handle the given load event.
|
void |
DefaultLockEventListener.onLock(LockEvent event)
Handle the given lock event.
|
void |
DefaultMergeEventListener.onMerge(MergeEvent event)
Handle the given merge event.
|
void |
DefaultMergeEventListener.onMerge(MergeEvent event,
Map copiedAlready)
Handle the given merge event.
|
void |
DefaultPersistEventListener.onPersist(PersistEvent event)
Handle the given create event.
|
void |
DefaultPersistEventListener.onPersist(PersistEvent event,
Map createCache)
Handle the given create event.
|
void |
DefaultRefreshEventListener.onRefresh(RefreshEvent event) |
protected void |
AbstractFlushingEventListener.performExecutions(EventSource session)
Execute all SQL and second-level cache updates, in a
special order so that foreign-key constraints cannot
be violated:
Inserts, in the order they were performed
Updates
Deletion of collection elements
Insertion of collection elements
Deletes, in the order they were performed
|
protected void |
DefaultSaveOrUpdateEventListener.performUpdate(SaveOrUpdateEvent event,
Object entity,
EntityPersister persister) |
protected void |
AbstractFlushingEventListener.postFlush(SessionImplementor session)
1.
|
void |
AbstractVisitor.processEntityPropertyValues(Object[] values,
Type[] types)
Dispatch each property value to processValue().
|
protected void |
ProxyVisitor.reattachCollection(PersistentCollection collection,
CollectionType type)
Reattach a detached (disassociated) initialized or uninitialized
collection wrapper, using a snapshot carried with the collection
wrapper
|
Modifier and Type | Class and Description |
---|---|
class |
ConstraintViolationException
Implementation of JDBCException indicating that the requested DML operation
resulted in a violation of a defined integrity constraint.
|
class |
DataException
Implementation of JDBCException indicating that evaluation of the
valid SQL statement against the given data resulted in some
illegal operation, mismatched types or incorrect cardinality.
|
class |
GenericJDBCException
Generic, non-specific JDBCException.
|
class |
JDBCConnectionException
Implementation of JDBCException indicating problems with communicating with the
database (can also include incorrect JDBC setup).
|
class |
LockAcquisitionException
Implementation of JDBCException indicating a problem acquiring lock
on the database.
|
class |
SQLGrammarException
Implementation of JDBCException indicating that the SQL sent to the database
server was invalid (syntax error, invalid object references, etc).
|
Modifier and Type | Method and Description |
---|---|
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.
|
Modifier and Type | Class and Description |
---|---|
class |
QueryExecutionRequestException
Expecting to execute an illegal operation regarding the query type
|
Modifier and Type | Method and Description |
---|---|
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.
|
Modifier and Type | Class and Description |
---|---|
class |
InvalidWithClauseException
Exception thrown when there is a syntax error in the HQL.
|
class |
QuerySyntaxException
Exception thrown when there is a syntax error in the HQL.
|
Modifier and Type | Method and Description |
---|---|
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() |
Modifier and Type | Method and Description |
---|---|
int |
MultiTableDeleteExecutor.execute(QueryParameters parameters,
SessionImplementor session) |
int |
BasicExecutor.execute(QueryParameters parameters,
SessionImplementor session) |
int |
MultiTableUpdateExecutor.execute(QueryParameters parameters,
SessionImplementor session) |
int |
StatementExecutor.execute(QueryParameters parameters,
SessionImplementor session)
Execute the sql managed by this executor using the given parameters.
|
Modifier and Type | Method and Description |
---|---|
int |
QueryTranslatorImpl.executeUpdate(QueryParameters queryParameters,
SessionImplementor session) |
protected Object |
QueryTranslatorImpl.getResultColumnOrRow(Object[] row,
ResultTransformer transformer,
ResultSet rs,
SessionImplementor session) |
Iterator |
QueryTranslatorImpl.iterate(QueryParameters queryParameters,
EventSource session)
Return the query results as an iterator
|
List |
QueryTranslatorImpl.list(SessionImplementor session,
QueryParameters queryParameters) |
ScrollableResults |
QueryTranslatorImpl.scroll(QueryParameters queryParameters,
SessionImplementor session) |
void |
QueryTranslatorImpl.validateScrollability() |
Modifier and Type | Class and Description |
---|---|
class |
IdentifierGenerationException
Thrown by IdentifierGenerator implementation class when
ID generation fails.
|
Modifier and Type | Method and Description |
---|---|
Serializable |
Assigned.generate(SessionImplementor session,
Object obj) |
Serializable |
IncrementGenerator.generate(SessionImplementor session,
Object object) |
Serializable |
UUIDGenerator.generate(SessionImplementor session,
Object object) |
Serializable |
IdentifierGenerator.generate(SessionImplementor session,
Object object)
Generate a new identifier.
|
Serializable |
GUIDGenerator.generate(SessionImplementor session,
Object obj) |
Serializable |
MultipleHiLoPerTableGenerator.generate(SessionImplementor session,
Object obj) |
Serializable |
CompositeNestedGeneratedValueGenerator.generate(SessionImplementor session,
Object object) |
static Serializable |
IdentifierGeneratorHelper.getGeneratedIdentity(ResultSet rs,
String identifierColumnName,
Type type)
Get the generated identifier when using identity columns
|
InsertGeneratedIdentifierDelegate |
SequenceIdentityGenerator.getInsertGeneratedIdentifierDelegate(PostInsertIdentityPersister persister,
Dialect dialect,
boolean isGetGeneratedKeysEnabled) |
InsertGeneratedIdentifierDelegate |
PostInsertIdentifierGenerator.getInsertGeneratedIdentifierDelegate(PostInsertIdentityPersister persister,
Dialect dialect,
boolean isGetGeneratedKeysEnabled) |
InsertGeneratedIdentifierDelegate |
IdentityGenerator.getInsertGeneratedIdentifierDelegate(PostInsertIdentityPersister persister,
Dialect dialect,
boolean isGetGeneratedKeysEnabled) |
InsertGeneratedIdentifierDelegate |
SelectGenerator.getInsertGeneratedIdentifierDelegate(PostInsertIdentityPersister persister,
Dialect dialect,
boolean isGetGeneratedKeysEnabled) |
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.sqlCreateStrings(Dialect dialect) |
String[] |
PersistentIdentifierGenerator.sqlDropStrings(Dialect dialect)
The SQL required to remove the underlying database objects.
|
String[] |
SequenceGenerator.sqlDropStrings(Dialect dialect) |
String[] |
MultipleHiLoPerTableGenerator.sqlDropStrings(Dialect dialect) |
Modifier and Type | Method and Description |
---|---|
Serializable |
SequenceStyleGenerator.generate(SessionImplementor session,
Object object)
Generate a new identifier.
|
String[] |
TableGenerator.sqlCreateStrings(Dialect dialect)
The SQL required to create the underlying database objects.
|
String[] |
SequenceStyleGenerator.sqlCreateStrings(Dialect dialect)
The SQL required to create the underlying database objects.
|
String[] |
TableStructure.sqlCreateStrings(Dialect dialect)
Commands needed to create the underlying structures.
|
String[] |
SequenceStructure.sqlCreateStrings(Dialect dialect)
Commands needed to create the underlying structures.
|
String[] |
TableGenerator.sqlDropStrings(Dialect dialect)
The SQL required to remove the underlying database objects.
|
String[] |
SequenceStyleGenerator.sqlDropStrings(Dialect dialect)
The SQL required to remove the underlying database objects.
|
String[] |
TableStructure.sqlDropStrings(Dialect dialect)
Commands needed to drop the underlying structures.
|
String[] |
SequenceStructure.sqlDropStrings(Dialect dialect)
Commands needed to drop the underlying structures.
|
Modifier and Type | Method and Description |
---|---|
void |
ScrollableResultsImpl.afterLast() |
void |
FetchingScrollableResultsImpl.afterLast()
Go to a location just after the last result
|
void |
SessionImpl.applyNonFlushedChanges(NonFlushedChanges nonFlushedChanges)
Apply non-flushed changes from a different session to this session.
|
protected boolean |
StatelessSessionImpl.autoFlushIfRequired(Set querySpaces) |
protected boolean |
SessionImpl.autoFlushIfRequired(Set querySpaces)
detect in-memory changes, determine if the changes are to tables
named in the query and, if so, complete execution the flush
|
void |
ScrollableResultsImpl.beforeFirst() |
void |
FetchingScrollableResultsImpl.beforeFirst()
Go to a location just before first result (this is the initial location)
|
Transaction |
StatelessSessionImpl.beginTransaction() |
Transaction |
SessionImpl.beginTransaction() |
void |
SessionImpl.cancelQuery() |
void |
SessionFactoryImpl.close()
Closes the session factory, releasing all held resources.
|
void |
AbstractScrollableResults.close() |
Connection |
SessionImpl.close() |
Connection |
SessionImpl.connection() |
Criteria |
CriteriaImpl.Subcriteria.createAlias(String associationPath,
String alias,
int joinType) |
Criteria |
CriteriaImpl.Subcriteria.createAlias(String associationPath,
String alias,
int joinType,
Criterion withClause) |
Criteria |
CriteriaImpl.Subcriteria.createCriteria(String associationPath,
int joinType) |
Criteria |
CriteriaImpl.Subcriteria.createCriteria(String associationPath,
String alias,
int joinType) |
Criteria |
CriteriaImpl.Subcriteria.createCriteria(String associationPath,
String alias,
int joinType,
Criterion withClause) |
void |
SessionImpl.delete(Object object)
Delete a persistent object
|
int |
SessionImpl.delete(String query) |
void |
SessionImpl.delete(String entityName,
Object object)
Delete a persistent object (by explicit entity name)
|
int |
SessionImpl.delete(String query,
Object[] values,
Type[] types) |
void |
SessionImpl.delete(String entityName,
Object object,
boolean isCascadeDeleteEnabled,
Set transientEntities)
Delete a persistent object
|
int |
SessionImpl.delete(String query,
Object value,
Type type) |
protected Type |
AbstractQueryImpl.determineType(int paramPosition,
Object paramValue) |
protected Type |
AbstractQueryImpl.determineType(String paramName,
Class clazz) |
protected Type |
AbstractQueryImpl.determineType(String paramName,
Object paramValue) |
Connection |
SessionImpl.disconnect() |
void |
SessionImpl.doWork(Work work) |
void |
SessionFactoryImpl.evict(Class persistentClass) |
void |
SessionFactoryImpl.evict(Class persistentClass,
Serializable id) |
void |
SessionImpl.evict(Object object)
remove any hard references to the entity that are held by the infrastructure
(references held by application or other persistant instances are okay)
|
void |
SessionFactoryImpl.evictCollection(String roleName) |
void |
SessionFactoryImpl.evictCollection(String roleName,
Serializable id) |
void |
SessionFactoryImpl.evictEntity(String entityName) |
void |
SessionFactoryImpl.evictEntity(String entityName,
Serializable id) |
void |
SessionFactoryImpl.evictQueries() |
void |
SessionFactoryImpl.evictQueries(String regionName) |
int |
StatelessSessionImpl.executeNativeUpdate(NativeSQLQuerySpecification nativeSQLQuerySpecification,
QueryParameters queryParameters) |
int |
SessionImpl.executeNativeUpdate(NativeSQLQuerySpecification nativeQuerySpecification,
QueryParameters queryParameters) |
int |
SQLQueryImpl.executeUpdate() |
int |
QueryImpl.executeUpdate() |
int |
StatelessSessionImpl.executeUpdate(String query,
QueryParameters queryParameters) |
int |
SessionImpl.executeUpdate(String query,
QueryParameters queryParameters) |
Collection |
SessionImpl.filter(Object collection,
String filter) |
Collection |
SessionImpl.filter(Object collection,
String filter,
Object[] values,
Type[] types) |
Collection |
SessionImpl.filter(Object collection,
String filter,
Object value,
Type type) |
List |
SessionImpl.find(String query)
Retrieve a list of persistent objects using a hibernate query
|
List |
SessionImpl.find(String query,
Object[] values,
Type[] types) |
List |
SessionImpl.find(String query,
Object value,
Type type) |
boolean |
ScrollableResultsImpl.first() |
boolean |
FetchingScrollableResultsImpl.first()
Go to the first result
|
void |
SessionImpl.flush() |
void |
SessionImpl.forceFlush(EntityEntry entityEntry) |
Object[] |
AbstractScrollableResults.get() |
Object |
SessionImpl.get(Class entityClass,
Serializable id) |
Object |
SessionImpl.get(Class entityClass,
Serializable id,
LockMode lockMode) |
Object |
SessionImpl.get(Class entityClass,
Serializable id,
LockOptions lockOptions) |
Object |
AbstractScrollableResults.get(int col) |
Object |
SessionImpl.get(String entityName,
Serializable id) |
Object |
SessionImpl.get(String entityName,
Serializable id,
LockMode lockMode) |
Object |
SessionImpl.get(String entityName,
Serializable id,
LockOptions lockOptions) |
Map<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 |
SQLQueryImpl.iterate() |
Iterator |
CollectionFilterImpl.iterate() |
Iterator |
QueryImpl.iterate() |
Iterator |
SessionImpl.iterate(String query) |
Iterator |
SessionImpl.iterate(String query,
Object[] values,
Type[] types) |
Iterator |
SessionImpl.iterate(String query,
Object value,
Type type) |
Iterator |
StatelessSessionImpl.iterate(String query,
QueryParameters queryParameters) |
Iterator |
SessionImpl.iterate(String query,
QueryParameters queryParameters) |
Iterator |
StatelessSessionImpl.iterateFilter(Object collection,
String filter,
QueryParameters queryParameters) |
Iterator |
SessionImpl.iterateFilter(Object collection,
String filter,
QueryParameters queryParameters) |
boolean |
ScrollableResultsImpl.last() |
boolean |
FetchingScrollableResultsImpl.last()
Go to the last result
|
List |
SQLQueryImpl.list() |
List |
CriteriaImpl.list() |
List |
CriteriaImpl.Subcriteria.list() |
List |
CollectionFilterImpl.list() |
List |
QueryImpl.list() |
List |
StatelessSessionImpl.list(CriteriaImpl criteria) |
List |
SessionImpl.list(CriteriaImpl criteria) |
List |
AbstractSessionImpl.list(NativeSQLQuerySpecification spec,
QueryParameters queryParameters) |
List |
StatelessSessionImpl.list(String query,
QueryParameters queryParameters) |
List |
SessionImpl.list(String query,
QueryParameters queryParameters) |
List |
StatelessSessionImpl.listCustomQuery(CustomQuery customQuery,
QueryParameters queryParameters) |
List |
SessionImpl.listCustomQuery(CustomQuery customQuery,
QueryParameters queryParameters) |
List |
StatelessSessionImpl.listFilter(Object collection,
String filter,
QueryParameters queryParameters) |
List |
SessionImpl.listFilter(Object collection,
String filter,
QueryParameters queryParameters) |
Object |
SessionImpl.load(Class entityClass,
Serializable id) |
Object |
SessionImpl.load(Class entityClass,
Serializable id,
LockMode lockMode) |
Object |
SessionImpl.load(Class entityClass,
Serializable id,
LockOptions lockOptions) |
void |
SessionImpl.load(Object object,
Serializable id) |
Object |
SessionImpl.load(String entityName,
Serializable id) |
Object |
SessionImpl.load(String entityName,
Serializable id,
LockMode lockMode) |
Object |
SessionImpl.load(String entityName,
Serializable id,
LockOptions lockOptions) |
void |
SessionImpl.lock(Object object,
LockMode lockMode) |
void |
SessionImpl.lock(String entityName,
Object object,
LockMode lockMode) |
Object |
SessionImpl.merge(Object object) |
Object |
SessionImpl.merge(String entityName,
Object object) |
void |
SessionImpl.merge(String entityName,
Object object,
Map copiedAlready) |
boolean |
ScrollableResultsImpl.next() |
Object |
IteratorImpl.next() |
boolean |
FetchingScrollableResultsImpl.next()
Advance to the next result
|
Session |
SessionFactoryImpl.openSession() |
Session |
SessionFactoryImpl.openSession(Connection connection,
boolean flushBeforeCompletionEnabled,
boolean autoCloseSessionEnabled,
ConnectionReleaseMode connectionReleaseMode) |
Session |
SessionFactoryImpl.openSession(Interceptor sessionLocalInterceptor) |
Session |
SessionFactoryImpl.openTemporarySession() |
void |
SessionImpl.persist(Object object) |
void |
SessionImpl.persist(String entityName,
Object object) |
void |
SessionImpl.persist(String entityName,
Object object,
Map copiedAlready) |
void |
SessionImpl.persistOnFlush(Object object) |
void |
SessionImpl.persistOnFlush(String entityName,
Object object) |
void |
SessionImpl.persistOnFlush(String entityName,
Object object,
Map copiedAlready) |
boolean |
ScrollableResultsImpl.previous() |
boolean |
FetchingScrollableResultsImpl.previous()
Retreat to the previous result
|
void |
SessionImpl.reconnect() |
void |
SessionImpl.reconnect(Connection conn) |
void |
SessionImpl.refresh(Object object) |
void |
SessionImpl.refresh(Object object,
LockMode lockMode) |
void |
SessionImpl.refresh(Object object,
LockOptions lockOptions) |
void |
SessionImpl.refresh(Object object,
Map refreshedAlready) |
void |
SessionImpl.replicate(Object obj,
ReplicationMode replicationMode) |
void |
SessionImpl.replicate(String entityName,
Object obj,
ReplicationMode replicationMode) |
Serializable |
SessionImpl.save(Object obj) |
void |
SessionImpl.save(Object obj,
Serializable id) |
Serializable |
SessionImpl.save(String entityName,
Object object) |
void |
SessionImpl.save(String entityName,
Object object,
Serializable id) |
void |
SessionImpl.saveOrUpdate(Object object) |
void |
SessionImpl.saveOrUpdate(String entityName,
Object obj) |
Object |
SessionImpl.saveOrUpdateCopy(Object object) |
Object |
SessionImpl.saveOrUpdateCopy(Object object,
Serializable id) |
Object |
SessionImpl.saveOrUpdateCopy(String entityName,
Object object) |
void |
SessionImpl.saveOrUpdateCopy(String entityName,
Object object,
Map copiedAlready) |
Object |
SessionImpl.saveOrUpdateCopy(String entityName,
Object object,
Serializable id) |
ScrollableResults |
SQLQueryImpl.scroll() |
ScrollableResults |
CriteriaImpl.Subcriteria.scroll() |
ScrollableResults |
CollectionFilterImpl.scroll() |
ScrollableResults |
QueryImpl.scroll() |
boolean |
ScrollableResultsImpl.scroll(int i) |
boolean |
FetchingScrollableResultsImpl.scroll(int positions)
Scroll an arbitrary number of locations
|
ScrollableResults |
AbstractSessionImpl.scroll(NativeSQLQuerySpecification spec,
QueryParameters queryParameters) |
ScrollableResults |
SQLQueryImpl.scroll(ScrollMode scrollMode) |
ScrollableResults |
CriteriaImpl.Subcriteria.scroll(ScrollMode scrollMode) |
ScrollableResults |
QueryImpl.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) |
Query |
AbstractQueryImpl.setParameterList(String name,
Collection vals) |
Filter |
FilterImpl.setParameterList(String name,
Collection values)
Set the named parameter's value list for this filter.
|
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 |
AbstractQueryImpl.uniqueResult() |
Object |
CriteriaImpl.uniqueResult() |
Object |
CriteriaImpl.Subcriteria.uniqueResult() |
void |
SessionImpl.update(Object obj) |
void |
SessionImpl.update(Object obj,
Serializable id) |
void |
SessionImpl.update(String entityName,
Object object) |
void |
SessionImpl.update(String entityName,
Object object,
Serializable id) |
void |
FilterImpl.validate()
Perform validation of the filter state.
|
protected void |
AbstractQueryImpl.verifyParameters(boolean reserveFirstParameter)
Perform parameter validation.
|
Constructor and Description |
---|
IteratorImpl(ResultSet rs,
PreparedStatement ps,
EventSource sess,
boolean readOnly,
Type[] types,
String[][] columnNames,
HolderInstantiator holderInstantiator) |
SessionFactoryImpl(Configuration cfg,
Mapping mapping,
Settings settings,
EventListeners listeners,
SessionFactoryObserver observer) |
Modifier and Type | Method and Description |
---|---|
Object |
LazyPropertyInitializer.initializeLazyProperty(String fieldName,
Object entity,
SessionImplementor session)
Initialize the property, and return its new value
|
Modifier and Type | Class and Description |
---|---|
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.
|
Modifier and Type | Method and Description |
---|---|
void |
NonBatchingBatcher.addToBatch(Expectation expectation) |
void |
BatchingBatcher.addToBatch(Expectation expectation) |
void |
Batcher.addToBatch(Expectation expectation)
Add an insert / delete / update to the current batch (might be called multiple times
for single prepareBatchStatement())
|
void |
Batcher.cancelLastQuery()
Cancel the current query statement
|
void |
AbstractBatcher.cancelLastQuery() |
void |
Batcher.closeConnection(Connection conn)
Deprecated.
Obtain connections from
ConnectionProvider instead |
void |
AbstractBatcher.closeConnection(Connection conn) |
Connection |
JDBCContext.connection() |
protected void |
NonBatchingBatcher.doExecuteBatch(PreparedStatement ps) |
protected void |
BatchingBatcher.doExecuteBatch(PreparedStatement ps) |
protected abstract void |
AbstractBatcher.doExecuteBatch(PreparedStatement ps) |
void |
Batcher.executeBatch()
Execute the batch
|
void |
AbstractBatcher.executeBatch() |
Connection |
ConnectionManager.getConnection()
Retrieves the connection currently managed by this ConnectionManager.
|
Transaction |
JDBCContext.getTransaction() |
Connection |
Batcher.openConnection()
Deprecated.
Obtain connections from
ConnectionProvider instead |
Connection |
AbstractBatcher.openConnection() |
int |
Expectations.BasicExpectation.prepare(PreparedStatement statement) |
int |
Expectations.BasicParamExpectation.prepare(PreparedStatement statement) |
int |
Expectation.prepare(PreparedStatement statement)
Perform any special statement preparation.
|
CallableStatement |
Batcher.prepareBatchCallableStatement(String sql)
Get a batchable callable statement to use for inserting / deleting / updating
(might be called many times before a single call to executeBatch()).
|
CallableStatement |
AbstractBatcher.prepareBatchCallableStatement(String sql) |
PreparedStatement |
Batcher.prepareBatchStatement(String sql)
Get a batchable prepared statement to use for inserting / deleting / updating
(might be called many times before a single call to executeBatch()).
|
PreparedStatement |
AbstractBatcher.prepareBatchStatement(String sql) |
CallableStatement |
Batcher.prepareCallableQueryStatement(String sql,
boolean scrollable,
ScrollMode scrollMode)
Get a prepared statement for use in loading / querying.
|
CallableStatement |
AbstractBatcher.prepareCallableQueryStatement(String sql,
boolean scrollable,
ScrollMode scrollMode) |
CallableStatement |
Batcher.prepareCallableStatement(String sql)
Get a non-batchable callable statement to use for inserting / deleting / updating.
|
CallableStatement |
AbstractBatcher.prepareCallableStatement(String sql) |
PreparedStatement |
Batcher.prepareQueryStatement(String sql,
boolean scrollable,
ScrollMode scrollMode)
Get a prepared statement for use in loading / querying.
|
PreparedStatement |
AbstractBatcher.prepareQueryStatement(String sql,
boolean scrollable,
ScrollMode scrollMode) |
PreparedStatement |
Batcher.prepareSelectStatement(String sql)
Get a non-batchable prepared statement to use for selecting.
|
PreparedStatement |
AbstractBatcher.prepareSelectStatement(String sql) |
PreparedStatement |
Batcher.prepareStatement(String sql)
Get a non-batchable prepared statement to use for inserting / deleting / updating.
|
PreparedStatement |
AbstractBatcher.prepareStatement(String sql) |
PreparedStatement |
Batcher.prepareStatement(String sql,
boolean useGetGeneratedKeys)
Get a non-batchable prepared statement to use for inserting / deleting / updating,
using JDBC3 getGeneratedKeys (
Connection.prepareStatement(String, int) ). |
PreparedStatement |
AbstractBatcher.prepareStatement(String sql,
boolean getGeneratedKeys) |
PreparedStatement |
Batcher.prepareStatement(String sql,
String[] columnNames)
Get a non-batchable prepared statement to use for inserting / deleting / updating.
|
PreparedStatement |
AbstractBatcher.prepareStatement(String sql,
String[] columnNames) |
void |
Expectation.verifyOutcome(int rowCount,
PreparedStatement statement,
int batchPosition)
Perform verification of the outcome of the RDBMS operation based on
the type of expectation defined.
|
Modifier and Type | Method and Description |
---|---|
void |
SessionFactoryStub.close() |
void |
HibernateServiceMBean.createSchema()
Export the CREATE DDL to the database
|
void |
HibernateServiceMBean.dropSchema()
Export the DROP DDL to the database
|
void |
SessionFactoryStub.evict(Class persistentClass) |
void |
SessionFactoryStub.evict(Class persistentClass,
Serializable id) |
void |
SessionFactoryStub.evictCollection(String roleName) |
void |
SessionFactoryStub.evictCollection(String roleName,
Serializable id) |
void |
SessionFactoryStub.evictEntity(String entityName) |
void |
SessionFactoryStub.evictEntity(String entityName,
Serializable id) |
void |
SessionFactoryStub.evictQueries() |
void |
SessionFactoryStub.evictQueries(String cacheRegion) |
Map<String,ClassMetadata> |
SessionFactoryStub.getAllClassMetadata() |
Map |
SessionFactoryStub.getAllCollectionMetadata() |
ClassMetadata |
SessionFactoryStub.getClassMetadata(Class persistentClass) |
ClassMetadata |
SessionFactoryStub.getClassMetadata(String entityName) |
CollectionMetadata |
SessionFactoryStub.getCollectionMetadata(String roleName) |
FilterDefinition |
SessionFactoryStub.getFilterDefinition(String filterName) |
Session |
SessionFactoryStub.openSession() |
Session |
SessionFactoryStub.openSession(Interceptor interceptor) |
void |
HibernateServiceMBean.start()
Create the SessionFactory and bind to the jndi name on startup
|
void |
HibernateService.start() |
Modifier and Type | Class and Description |
---|---|
class |
MultipleBagFetchException
Exception used to indicate that a query is attempting to simultaneously fetch multiple
bags |
Modifier and Type | Method and Description |
---|---|
protected String |
Loader.applyLocks(String sql,
LockOptions lockOptions,
Dialect dialect)
Append FOR UPDATE OF clause, if necessary.
|
protected int |
Loader.bindNamedParameters(PreparedStatement statement,
Map namedParams,
int startIndex,
SessionImplementor session)
Bind named parameters to the JDBC prepared statement.
|
protected int |
Loader.bindPositionalParameters(PreparedStatement statement,
QueryParameters queryParameters,
int startIndex,
SessionImplementor session)
Bind positional parameter values to the JDBC prepared statement.
|
protected void |
Loader.checkScrollability()
Check whether the current loader can support returning ScrollableResults.
|
protected List |
Loader.doList(SessionImplementor session,
QueryParameters queryParameters)
Actually execute a query, ignoring the query cache
|
protected Object |
Loader.getResultColumnOrRow(Object[] row,
ResultTransformer transformer,
ResultSet rs,
SessionImplementor session)
Get the actual object that is returned in the user-visible result list.
|
protected ResultSet |
Loader.getResultSet(PreparedStatement st,
boolean autodiscovertypes,
boolean callable,
RowSelection selection,
SessionImplementor session)
Fetch a PreparedStatement, call setMaxRows and then execute it,
advance to the first result and return an SQL ResultSet
|
protected List |
Loader.list(SessionImplementor session,
QueryParameters queryParameters,
Set querySpaces,
Type[] resultTypes)
Return the query results, using the query cache, called
by subclasses that implement cacheable queries
|
void |
Loader.loadCollection(SessionImplementor session,
Serializable id,
Type type)
Called by subclasses that initialize collections
|
void |
Loader.loadCollectionBatch(SessionImplementor session,
Serializable[] ids,
Type type)
Called by wrappers that batch initialize collections
|
protected void |
Loader.loadCollectionSubselect(SessionImplementor session,
Serializable[] ids,
Object[] parameterValues,
Type[] parameterTypes,
Map namedParameters,
Type type)
Called by subclasses that batch initialize collections
|
protected List |
Loader.loadEntity(SessionImplementor session,
Object key,
Object index,
Type keyType,
Type indexType,
EntityPersister persister)
Called by subclasses that load entities
|
protected List |
Loader.loadEntity(SessionImplementor session,
Object id,
Type identifierType,
Object optionalObject,
String optionalEntityName,
Serializable optionalIdentifier,
EntityPersister persister,
LockOptions lockOptions)
Called by subclasses that load entities
|
List |
Loader.loadEntityBatch(SessionImplementor session,
Serializable[] ids,
Type idType,
Object optionalObject,
String optionalEntityName,
Serializable optionalId,
EntityPersister persister,
LockOptions lockOptions)
Called by wrappers that batch load entities
|
Object |
Loader.loadSequentialRowsForward(ResultSet resultSet,
SessionImplementor session,
QueryParameters queryParameters,
boolean returnProxies)
Loads a single logical row from the result set moving forward.
|
Object |
Loader.loadSequentialRowsReverse(ResultSet resultSet,
SessionImplementor session,
QueryParameters queryParameters,
boolean returnProxies,
boolean isLogicallyAfterLast)
Loads a single logical row from the result set moving forward.
|
Object |
Loader.loadSingleRow(ResultSet resultSet,
SessionImplementor session,
QueryParameters queryParameters,
boolean returnProxies)
Loads a single row from the result set.
|
protected PreparedStatement |
Loader.prepareQueryStatement(QueryParameters queryParameters,
boolean scroll,
SessionImplementor session)
Obtain a PreparedStatement with all parameters pre-bound.
|
protected String |
Loader.preprocessSQL(String sql,
QueryParameters parameters,
Dialect dialect)
Modify the SQL, adding lock hints and comments, if necessary
|
protected ScrollableResults |
Loader.scroll(QueryParameters queryParameters,
Type[] returnTypes,
HolderInstantiator holderInstantiator,
SessionImplementor session)
Return the query results, as an instance of ScrollableResults
|
Modifier and Type | Method and Description |
---|---|
void |
CollectionInitializer.initialize(Serializable id,
SessionImplementor session)
Initialize the given collection
|
void |
SubselectOneToManyLoader.initialize(Serializable id,
SessionImplementor session) |
void |
CollectionLoader.initialize(Serializable id,
SessionImplementor session) |
void |
BatchingCollectionInitializer.initialize(Serializable id,
SessionImplementor session) |
void |
SubselectCollectionLoader.initialize(Serializable id,
SessionImplementor session) |
Modifier and Type | Method and Description |
---|---|
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) |
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) |
Constructor and Description |
---|
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) |
Modifier and Type | Method and Description |
---|---|
Object |
CustomLoader.ResultRowProcessor.buildResultRow(Object[] data,
ResultSet resultSet,
boolean hasTransformer,
SessionImplementor session)
Build a logical result row.
|
Object |
CustomLoader.NonScalarResultColumnProcessor.extract(Object[] data,
ResultSet resultSet,
SessionImplementor session) |
Object |
CustomLoader.ScalarResultColumnProcessor.extract(Object[] data,
ResultSet resultSet,
SessionImplementor session) |
protected Object |
CustomLoader.getResultColumnOrRow(Object[] row,
ResultTransformer transformer,
ResultSet rs,
SessionImplementor session) |
List |
CustomLoader.list(SessionImplementor session,
QueryParameters queryParameters) |
ScrollableResults |
CustomLoader.scroll(QueryParameters queryParameters,
SessionImplementor session) |
Constructor and Description |
---|
SQLCustomQuery(String sqlQuery,
NativeSQLQueryReturn[] queryReturns,
Collection additionalQuerySpaces,
SessionFactoryImplementor factory) |
Modifier and Type | Method and Description |
---|---|
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.
|
Object |
CollectionElementLoader.loadElement(SessionImplementor session,
Object key,
Object index) |
Modifier and Type | Method and Description |
---|---|
protected Object |
QueryLoader.getResultColumnOrRow(Object[] row,
ResultTransformer transformer,
ResultSet rs,
SessionImplementor session) |
Iterator |
QueryLoader.iterate(QueryParameters queryParameters,
EventSource session) |
List |
QueryLoader.list(SessionImplementor session,
QueryParameters queryParameters) |
ScrollableResults |
QueryLoader.scroll(QueryParameters queryParameters,
SessionImplementor session) |
void |
QueryLoader.validateScrollability() |
Modifier and Type | Method and Description |
---|---|
String |
Column.getSqlType(Dialect dialect,
Mapping mapping) |
Iterator |
Table.sqlAlterStrings(Dialect dialect,
Mapping p,
TableMetadata tableInfo,
String defaultCatalog,
String defaultSchema) |
String |
SimpleAuxiliaryDatabaseObject.sqlCreateString(Dialect dialect,
Mapping p,
String defaultCatalog,
String defaultSchema) |
String |
Index.sqlCreateString(Dialect dialect,
Mapping mapping,
String defaultCatalog,
String defaultSchema) |
String |
RelationalModel.sqlCreateString(Dialect dialect,
Mapping p,
String defaultCatalog,
String defaultSchema) |
String |
Table.sqlTemporaryTableCreateString(Dialect dialect,
Mapping mapping) |
Modifier and Type | Method and Description |
---|---|
Serializable |
ClassMetadata.getIdentifier(Object object,
EntityMode entityMode)
Deprecated.
|
Type |
ClassMetadata.getPropertyType(String propertyName)
Get the type of a particular (named) property
|
Object |
ClassMetadata.getPropertyValue(Object object,
String propertyName,
EntityMode entityMode)
Get the value of a particular (named) property
|
Object[] |
ClassMetadata.getPropertyValues(Object entity,
EntityMode entityMode)
Extract the property values from the given entity.
|
Object[] |
ClassMetadata.getPropertyValuesToInsert(Object entity,
Map mergeMap,
SessionImplementor session)
Return the values of the mapped properties of the object
|
Object |
ClassMetadata.getVersion(Object object,
EntityMode entityMode)
Get the version number (or timestamp) from the object's version property
(or return null if not versioned)
|
Object |
ClassMetadata.instantiate(Serializable id,
EntityMode entityMode)
Deprecated.
|
void |
ClassMetadata.setIdentifier(Object entity,
Serializable id,
EntityMode entityMode)
Deprecated.
|
void |
ClassMetadata.setPropertyValue(Object object,
String propertyName,
Object value,
EntityMode entityMode)
Set the value of a particular (named) property
|
void |
ClassMetadata.setPropertyValues(Object object,
Object[] values,
EntityMode entityMode)
Set the given values to the mapped properties of the given object
|
Modifier and Type | Method and Description |
---|---|
static EntityPersister |
PersisterFactory.createClassPersister(PersistentClass model,
EntityRegionAccessStrategy cacheAccessStrategy,
SessionFactoryImplementor factory,
Mapping cfg) |
static CollectionPersister |
PersisterFactory.createCollectionPersister(Configuration cfg,
Collection model,
CollectionRegionAccessStrategy cacheAccessStrategy,
SessionFactoryImplementor factory) |
Modifier and Type | Method and Description |
---|---|
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 |
OneToManyPersister.doUpdateRows(Serializable id,
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
|
Modifier and Type | Method and Description |
---|---|
protected boolean |
AbstractEntityPersister.check(int rows,
Serializable id,
int tableNumber,
Expectation expectation,
PreparedStatement statement) |
Object |
EntityPersister.createProxy(Serializable id,
SessionImplementor session)
Create a new proxy instance
|
Object |
AbstractEntityPersister.createProxy(Serializable id,
SessionImplementor session) |
Object |
DiscriminatorType.deepCopy(Object value,
EntityMode entityMode,
SessionFactoryImplementor factory) |
protected int |
AbstractEntityPersister.dehydrate(Serializable id,
Object[] fields,
boolean[] includeProperty,
boolean[][] includeColumns,
int j,
PreparedStatement st,
SessionImplementor session) |
protected int |
AbstractEntityPersister.dehydrate(Serializable id,
Object[] fields,
Object rowId,
boolean[] includeProperty,
boolean[][] includeColumns,
int j,
PreparedStatement ps,
SessionImplementor session,
int index)
Marshall the fields of a persistent instance to a prepared statement
|
protected void |
AbstractEntityPersister.delete(Serializable id,
Object version,
int j,
Object object,
String sql,
SessionImplementor session,
Object[] loadedState)
Perform an SQL DELETE
|
void |
EntityPersister.delete(Serializable id,
Object version,
Object object,
SessionImplementor session)
Delete a persistent instance
|
void |
AbstractEntityPersister.delete(Serializable id,
Object version,
Object object,
SessionImplementor session)
Delete an object
|
int[] |
AbstractEntityPersister.findDirty(Object[] currentState,
Object[] previousState,
Object entity,
SessionImplementor session)
Locate the property-indices of all properties considered to be dirty.
|
int[] |
AbstractEntityPersister.findModified(Object[] old,
Object[] current,
Object entity,
SessionImplementor session)
Locate the property-indices of all properties considered to be dirty.
|
Object |
EntityPersister.forceVersionIncrement(Serializable id,
Object currentVersion,
SessionImplementor session) |
Object |
DiscriminatorType.fromXMLNode(org.dom4j.Node xml,
Mapping factory) |
Object |
EntityPersister.getCurrentVersion(Serializable id,
SessionImplementor session)
Get the current version of the object, or return null if there is no row for
the given identifier.
|
Object |
AbstractEntityPersister.getCurrentVersion(Serializable id,
SessionImplementor session)
Retrieve the version number
|
Object[] |
EntityPersister.getDatabaseSnapshot(Serializable id,
SessionImplementor session)
Get the current database state of the object, in a "hydrated" form, without
resolving identifiers
|
Object[] |
AbstractEntityPersister.getDatabaseSnapshot(Serializable id,
SessionImplementor session) |
Serializable |
EntityPersister.getIdentifier(Object object,
EntityMode entityMode)
Deprecated.
|
Serializable |
AbstractEntityPersister.getIdentifier(Object object,
EntityMode entityMode) |
IdentifierGenerator |
AbstractEntityPersister.getIdentifierGenerator() |
Object[] |
AbstractEntityPersister.getNaturalIdentifierSnapshot(Serializable id,
SessionImplementor session) |
Object |
EntityPersister.getPropertyValue(Object object,
int i,
EntityMode entityMode)
Get the value of a particular property
|
Object |
AbstractEntityPersister.getPropertyValue(Object object,
int i,
EntityMode entityMode) |
Object |
EntityPersister.getPropertyValue(Object object,
String propertyName,
EntityMode entityMode)
Get the value of a particular property
|
Object |
AbstractEntityPersister.getPropertyValue(Object object,
String propertyName,
EntityMode entityMode) |
Object[] |
EntityPersister.getPropertyValues(Object object,
EntityMode entityMode)
Return the (loaded) values of the mapped properties of the object (not including backrefs)
|
Object[] |
AbstractEntityPersister.getPropertyValues(Object object,
EntityMode entityMode) |
Object[] |
EntityPersister.getPropertyValuesToInsert(Object object,
Map mergeMap,
SessionImplementor session)
Return the values of the insertable properties of the object (including backrefs)
|
Object[] |
AbstractEntityPersister.getPropertyValuesToInsert(Object object,
Map mergeMap,
SessionImplementor session) |
Object |
EntityPersister.getVersion(Object object,
EntityMode entityMode)
Get the version number (or timestamp) from the object's version property (or return null if not versioned)
|
Object |
AbstractEntityPersister.getVersion(Object object,
EntityMode entityMode) |
Object[] |
Loadable.hydrate(ResultSet rs,
Serializable id,
Object object,
Loadable rootLoadable,
String[][] suffixedPropertyColumns,
boolean allProperties,
SessionImplementor session)
Retrieve property values from one row of a result set
|
Object[] |
AbstractEntityPersister.hydrate(ResultSet rs,
Serializable id,
Object object,
Loadable rootLoadable,
String[][] suffixedPropertyColumns,
boolean allProperties,
SessionImplementor session)
Unmarshall the fields of a persistent instance from a result set,
without resolving associations or collections.
|
Object |
AbstractEntityPersister.initializeLazyProperty(String fieldName,
Object entity,
SessionImplementor session) |
protected Serializable |
AbstractEntityPersister.insert(Object[] fields,
boolean[] notNull,
String sql,
Object object,
SessionImplementor session)
Perform an SQL INSERT, and then retrieve a generated identifier.
|
Serializable |
EntityPersister.insert(Object[] fields,
Object object,
SessionImplementor session)
Persist an instance, using a natively generated identifier (optional operation)
|
Serializable |
AbstractEntityPersister.insert(Object[] fields,
Object object,
SessionImplementor session) |
protected void |
AbstractEntityPersister.insert(Serializable id,
Object[] fields,
boolean[] notNull,
int j,
String sql,
Object object,
SessionImplementor session)
Perform an SQL INSERT.
|
void |
EntityPersister.insert(Serializable id,
Object[] fields,
Object object,
SessionImplementor session)
Persist an instance
|
void |
AbstractEntityPersister.insert(Serializable id,
Object[] fields,
Object object,
SessionImplementor session) |
Object |
EntityPersister.instantiate(Serializable id,
EntityMode entityMode)
Deprecated.
|
Object |
AbstractEntityPersister.instantiate(Serializable id,
EntityMode entityMode)
Create a class instance initialized with the given identifier
|
Object |
AbstractEntityPersister.instantiate(Serializable id,
SessionImplementor session)
Create a class instance initialized with the given identifier
|
boolean |
DiscriminatorType.isDirty(Object old,
Object current,
boolean[] checkable,
SessionImplementor session) |
Boolean |
EntityPersister.isTransient(Object object,
SessionImplementor session)
Is this a new transient instance?
|
Boolean |
AbstractEntityPersister.isTransient(Object entity,
SessionImplementor session) |
Object |
EntityPersister.load(Serializable id,
Object optionalObject,
LockMode lockMode,
SessionImplementor session)
Load an instance of the persistent class.
|
Object |
EntityPersister.load(Serializable id,
Object optionalObject,
LockOptions lockOptions,
SessionImplementor session)
Load an instance of the persistent class.
|
Object |
AbstractEntityPersister.load(Serializable id,
Object optionalObject,
LockOptions lockOptions,
SessionImplementor session)
Load an instance using either the forUpdateLoader or the outer joining loader,
depending upon the value of the lock parameter
|
Object |
UniqueKeyLoadable.loadByUniqueKey(String propertyName,
Object uniqueKey,
SessionImplementor session)
Load an instance of the persistent class, by a unique key other
than the primary key.
|
Object |
AbstractEntityPersister.loadByUniqueKey(String propertyName,
Object uniqueKey,
SessionImplementor session) |
void |
EntityPersister.lock(Serializable id,
Object version,
Object object,
LockMode lockMode,
SessionImplementor session)
Do a version check (optional operation)
|
void |
AbstractEntityPersister.lock(Serializable id,
Object version,
Object object,
LockMode lockMode,
SessionImplementor session) |
void |
EntityPersister.lock(Serializable id,
Object version,
Object object,
LockOptions lockOptions,
SessionImplementor session)
Do a version check (optional operation)
|
void |
AbstractEntityPersister.lock(Serializable id,
Object version,
Object object,
LockOptions lockOptions,
SessionImplementor session) |
Object |
DiscriminatorType.nullSafeGet(ResultSet rs,
String[] names,
SessionImplementor session,
Object owner) |
Object |
DiscriminatorType.nullSafeGet(ResultSet rs,
String name,
SessionImplementor session,
Object owner) |
void |
DiscriminatorType.nullSafeSet(PreparedStatement st,
Object value,
int index,
boolean[] settable,
SessionImplementor session) |
void |
DiscriminatorType.nullSafeSet(PreparedStatement st,
Object value,
int index,
SessionImplementor session) |
Object |
DiscriminatorType.replace(Object original,
Object target,
SessionImplementor session,
Object owner,
Map copyCache) |
void |
EntityPersister.setIdentifier(Object entity,
Serializable id,
EntityMode entityMode)
Deprecated.
|
void |
AbstractEntityPersister.setIdentifier(Object entity,
Serializable id,
EntityMode entityMode)
Inject the identifier value into the given entity.
|
void |
EntityPersister.setPropertyValue(Object object,
int i,
Object value,
EntityMode entityMode)
Set the value of a particular property
|
void |
AbstractEntityPersister.setPropertyValue(Object object,
int i,
Object value,
EntityMode entityMode) |
void |
AbstractEntityPersister.setPropertyValue(Object object,
String propertyName,
Object value,
EntityMode entityMode) |
void |
EntityPersister.setPropertyValues(Object object,
Object[] values,
EntityMode entityMode)
Set the given values to the mapped properties of the given object
|
void |
AbstractEntityPersister.setPropertyValues(Object object,
Object[] values,
EntityMode entityMode) |
void |
DiscriminatorType.setToXMLNode(org.dom4j.Node node,
Object value,
SessionFactoryImplementor factory) |
String |
DiscriminatorType.toLoggableString(Object value,
SessionFactoryImplementor factory) |
void |
EntityPersister.update(Serializable id,
Object[] fields,
int[] dirtyFields,
boolean hasDirtyCollection,
Object[] oldFields,
Object oldVersion,
Object object,
Object rowId,
SessionImplementor session)
Update a persistent instance
|
void |
AbstractEntityPersister.update(Serializable id,
Object[] fields,
int[] dirtyFields,
boolean hasDirtyCollection,
Object[] oldFields,
Object oldVersion,
Object object,
Object rowId,
SessionImplementor session)
Update an object
|
protected boolean |
AbstractEntityPersister.update(Serializable id,
Object[] fields,
Object[] oldFields,
Object rowId,
boolean[] includeProperty,
int j,
Object oldVersion,
Object object,
String sql,
SessionImplementor session) |
protected void |
AbstractEntityPersister.updateOrInsert(Serializable id,
Object[] fields,
Object[] oldFields,
Object rowId,
boolean[] includeProperty,
int j,
Object oldVersion,
Object object,
String sql,
SessionImplementor session)
Perform an SQL UPDATE or SQL INSERT
|
Constructor and Description |
---|
AbstractEntityPersister(PersistentClass persistentClass,
EntityRegionAccessStrategy cacheAccessStrategy,
SessionFactoryImplementor factory) |
JoinedSubclassEntityPersister(PersistentClass persistentClass,
EntityRegionAccessStrategy cacheAccessStrategy,
SessionFactoryImplementor factory,
Mapping mapping) |
SingleTableEntityPersister(PersistentClass persistentClass,
EntityRegionAccessStrategy cacheAccessStrategy,
SessionFactoryImplementor factory,
Mapping mapping) |
UnionSubclassEntityPersister(PersistentClass persistentClass,
EntityRegionAccessStrategy cacheAccessStrategy,
SessionFactoryImplementor factory,
Mapping mapping) |
Modifier and Type | Method and Description |
---|---|
void |
Printer.toString(Iterator iter,
EntityMode entityMode) |
String |
Printer.toString(Map namedTypedValues) |
String |
Printer.toString(Object entity,
EntityMode entityMode) |
String |
Printer.toString(Type[] types,
Object[] values) |
Modifier and Type | Method and Description |
---|---|
Object |
Dom4jAccessor.TextGetter.get(Object owner)
Get the property value from the given instance .
|
Object |
Dom4jAccessor.AttributeGetter.get(Object owner)
Get the property value from the given instance .
|
Object |
Dom4jAccessor.ElementGetter.get(Object owner)
Get the property value from the given instance .
|
Object |
Dom4jAccessor.ElementAttributeGetter.get(Object owner)
Get the property value from the given instance .
|
Object |
DirectPropertyAccessor.DirectGetter.get(Object target)
Get the property value from the given instance .
|
Object |
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 |
MapAccessor.MapGetter.get(Object target)
Get the property value from the given instance .
|
Object |
Dom4jAccessor.Dom4jGetter.getForInsert(Object owner,
Map mergeMap,
SessionImplementor session) |
Object |
IndexPropertyAccessor.IndexGetter.getForInsert(Object target,
Map mergeMap,
SessionImplementor session) |
Object |
Getter.getForInsert(Object owner,
Map mergeMap,
SessionImplementor session)
Get the property value from the given owner instance.
|
void |
Dom4jAccessor.TextSetter.set(Object target,
Object value,
SessionFactoryImplementor factory)
Set the property value from the given instance
|
void |
Dom4jAccessor.AttributeSetter.set(Object target,
Object value,
SessionFactoryImplementor factory)
Set the property value from the given instance
|
void |
Dom4jAccessor.ElementSetter.set(Object target,
Object value,
SessionFactoryImplementor factory)
Set the property value from the given instance
|
void |
Dom4jAccessor.ElementAttributeSetter.set(Object target,
Object value,
SessionFactoryImplementor factory)
Set the property value from the given instance
|
void |
DirectPropertyAccessor.DirectSetter.set(Object target,
Object value,
SessionFactoryImplementor factory)
Set the property value from the given instance
|
void |
BasicPropertyAccessor.BasicSetter.set(Object target,
Object value,
SessionFactoryImplementor factory) |
void |
Setter.set(Object target,
Object value,
SessionFactoryImplementor factory)
Set the property value from the given instance
|
void |
MapAccessor.MapSetter.set(Object target,
Object value,
SessionFactoryImplementor factory)
Set the property value from the given instance
|
Modifier and Type | Method and Description |
---|---|
Object |
AbstractLazyInitializer.getImplementation(SessionImplementor s)
Return the underlying persistent object in the given Session, or null,
do not initialize the proxy
|
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()
Initialize the proxy, fetching the target entity if necessary.
|
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)
Associate the proxy with the given session.
|
void |
LazyInitializer.setSession(SessionImplementor session)
Associate the proxy with the given session.
|
Modifier and Type | Method and Description |
---|---|
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
|
Modifier and Type | Method and Description |
---|---|
HibernateProxy |
MapProxyFactory.getProxy(Serializable id,
SessionImplementor session) |
void |
MapProxyFactory.postInstantiate(String entityName,
Class persistentClass,
Set interfaces,
Method getIdentifierMethod,
Method setIdentifierMethod,
CompositeType componentIdType) |
Modifier and Type | Method and Description |
---|---|
static HibernateProxy |
CGLIBLazyInitializer.getProxy(Class factory,
String entityName,
Class persistentClass,
Class[] interfaces,
Method getIdentifierMethod,
Method setIdentifierMethod,
CompositeType componentIdType,
Serializable id,
SessionImplementor session)
Deprecated.
|
HibernateProxy |
CGLIBProxyFactory.getProxy(Serializable id,
SessionImplementor session)
Deprecated.
|
static Class |
CGLIBLazyInitializer.getProxyFactory(Class persistentClass,
Class[] interfaces)
Deprecated.
|
void |
CGLIBProxyFactory.postInstantiate(String entityName,
Class persistentClass,
Set interfaces,
Method getIdentifierMethod,
Method setIdentifierMethod,
CompositeType componentIdType)
Deprecated.
|
Modifier and Type | Method and Description |
---|---|
static HibernateProxy |
JavassistLazyInitializer.getProxy(Class factory,
String entityName,
Class persistentClass,
Class[] interfaces,
Method getIdentifierMethod,
Method setIdentifierMethod,
CompositeType componentIdType,
Serializable id,
SessionImplementor session) |
HibernateProxy |
JavassistProxyFactory.getProxy(Serializable id,
SessionImplementor session) |
static HibernateProxy |
JavassistLazyInitializer.getProxy(String entityName,
Class persistentClass,
Class[] interfaces,
Method getIdentifierMethod,
Method setIdentifierMethod,
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) |
Constructor and Description |
---|
JACCConfiguration(String contextId) |
Modifier and Type | Method and Description |
---|---|
String[] |
ColumnMapper.map(String reference)
Resolve the property reference to its underlying columns.
|
Modifier and Type | Method and Description |
---|---|
Session |
FunctionalTestCase.openSession() |
Session |
FunctionalTestCase.openSession(Interceptor interceptor) |
Modifier and Type | Method and Description |
---|---|
void |
ConnectionProviderImpl.close() |
void |
ConnectionProviderImpl.configure(Properties props) |
TransactionManager |
TransactionManagerLookupImpl.getTransactionManager(Properties props) |
Modifier and Type | Method and Description |
---|---|
TableMetadata |
DatabaseMetadata.getTableMetadata(String name,
String schema,
String catalog,
boolean isQuoted) |
boolean |
DatabaseMetadata.isTable(Object key) |
Constructor and Description |
---|
SchemaExport(Configuration cfg)
Create a schema exporter for the given Configuration
|
SchemaExport(Configuration cfg,
Connection connection)
Create a schema exporter for the given Configuration, using the supplied connection for connectivity.
|
SchemaExport(Configuration cfg,
Properties properties)
Deprecated.
properties may be specified via the Configuration object
|
SchemaExport(Configuration cfg,
Settings settings)
Create a schema exporter for the given Configuration and given settings
|
SchemaUpdate(Configuration cfg) |
SchemaUpdate(Configuration cfg,
Properties connectionProperties) |
SchemaUpdate(Configuration cfg,
Settings settings) |
SchemaValidator(Configuration cfg) |
SchemaValidator(Configuration cfg,
Properties connectionProperties) |
SchemaValidator(Configuration cfg,
Settings settings) |
Modifier and Type | Method and Description |
---|---|
void |
CMTTransaction.begin()
Begin a new transaction.
|
void |
JDBCTransaction.begin()
Begin a new transaction.
|
void |
JTATransaction.begin()
Begin a new transaction.
|
static TransactionFactory |
TransactionFactoryFactory.buildTransactionFactory(Properties transactionProps)
Create an appropriate transaction factory based on the given configuration
properties.
|
void |
CMTTransaction.commit()
Flush the associated Session and end the unit of work (unless
we are in
FlushMode.MANUAL . |
void |
JDBCTransaction.commit()
Flush the associated Session and end the unit of work (unless
we are in
FlushMode.MANUAL . |
void |
JTATransaction.commit()
Flush the associated Session and end the unit of work (unless
we are in
FlushMode.MANUAL . |
void |
JDBCTransactionFactory.configure(Properties props)
Configure from the given properties.
|
void |
CMTTransactionFactory.configure(Properties props) |
void |
TransactionFactory.configure(Properties props)
Configure from the given properties.
|
void |
JTATransactionFactory.configure(Properties props)
Configure this transaction factory.
|
Transaction |
JDBCTransactionFactory.createTransaction(JDBCContext jdbcContext,
TransactionFactory.Context transactionContext)
Begin a transaction and return the associated Transaction instance.
|
Transaction |
CMTTransactionFactory.createTransaction(JDBCContext jdbcContext,
TransactionFactory.Context transactionContext) |
Transaction |
TransactionFactory.createTransaction(JDBCContext jdbcContext,
TransactionFactory.Context context)
Begin a transaction and return the associated Transaction instance.
|
Transaction |
JTATransactionFactory.createTransaction(JDBCContext jdbcContext,
TransactionFactory.Context transactionContext)
Begin a transaction and return the associated Transaction instance.
|
TransactionManager |
JNDITransactionManagerLookup.getTransactionManager(Properties props)
Obtain the JTA
TransactionManager . |
TransactionManager |
JOTMTransactionManagerLookup.getTransactionManager(Properties props)
Obtain the JTA
TransactionManager . |
TransactionManager |
WebSphereTransactionManagerLookup.getTransactionManager(Properties props)
Obtain the JTA
TransactionManager . |
TransactionManager |
JOnASTransactionManagerLookup.getTransactionManager(Properties props) |
TransactionManager |
BTMTransactionManagerLookup.getTransactionManager(Properties props)
Obtain the JTA
TransactionManager . |
static TransactionManager |
TransactionManagerLookupFactory.getTransactionManager(Properties props)
Convenience method for locating the JTA
TransactionManager from the
given platform config. |
TransactionManager |
JBossTSStandaloneTransactionManagerLookup.getTransactionManager(Properties props) |
TransactionManager |
TransactionManagerLookup.getTransactionManager(Properties props)
Obtain the JTA
TransactionManager . |
static TransactionManagerLookup |
TransactionManagerLookupFactory.getTransactionManagerLookup(Properties props)
Generate the appropriate
TransactionManagerLookup given the
config settings being passed. |
void |
CMTTransaction.registerSynchronization(Synchronization sync)
Register a user synchronization callback for this transaction.
|
void |
JTATransaction.registerSynchronization(Synchronization sync)
Register a user synchronization callback for this transaction.
|
void |
CMTTransaction.rollback()
Force the underlying transaction to roll back.
|
void |
JDBCTransaction.rollback()
Force the underlying transaction to roll back.
|
void |
JTATransaction.rollback()
Force the underlying transaction to roll back.
|
Modifier and Type | Method and Description |
---|---|
Object |
AbstractComponentTuplizer.getPropertyValue(Object component,
int i) |
Object[] |
AbstractComponentTuplizer.getPropertyValues(Object component) |
Object[] |
PojoComponentTuplizer.getPropertyValues(Object component) |
Object |
AbstractComponentTuplizer.instantiate()
This method does not populate the component parent
|
void |
AbstractComponentTuplizer.setPropertyValues(Object component,
Object[] values) |
void |
PojoComponentTuplizer.setPropertyValues(Object component,
Object[] values) |
Modifier and Type | Method and Description |
---|---|
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 |
Dom4jEntityTuplizer.getIdentifier(Object entityOrId)
Extract the identifier value from the given entity.
|
Serializable |
EntityTuplizer.getIdentifier(Object entity)
Deprecated.
|
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[] |
PojoEntityTuplizer.getPropertyValues(Object entity)
Extract the current values contained on the given entity.
|
Object[] |
AbstractEntityTuplizer.getPropertyValues(Object entity) |
Object[] |
PojoEntityTuplizer.getPropertyValuesToInsert(Object entity,
Map mergeMap,
SessionImplementor session)
Extract the values of the insertable properties of the entity (including backrefs)
|
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 |
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.
|
Object |
AbstractEntityTuplizer.instantiate(Serializable id) |
void |
EntityTuplizer.setIdentifier(Object entity,
Serializable id)
Deprecated.
|
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 |
PojoEntityTuplizer.setPropertyValues(Object entity,
Object[] values)
Inject the given values into the given entity.
|
void |
AbstractEntityTuplizer.setPropertyValues(Object entity,
Object[] values) |
Modifier and Type | Class and Description |
---|---|
class |
SerializationException
Thrown when a property cannot be serializaed/deserialized
|
Modifier and Type | Method and Description |
---|---|
Object |
StringClobType.assemble(Serializable cached,
Object owner)
Deprecated.
|
Object |
EnumType.assemble(Serializable cached,
Object owner) |
Object |
OneToOneType.assemble(Serializable oid,
SessionImplementor session,
Object owner) |
Object |
AbstractType.assemble(Serializable cached,
SessionImplementor session,
Object owner) |
Object |
CustomType.assemble(Serializable cached,
SessionImplementor session,
Object owner) |
Object |
CompositeCustomType.assemble(Serializable cached,
SessionImplementor session,
Object owner) |
Object |
AnyType.assemble(Serializable cached,
SessionImplementor session,
Object owner) |
Object |
SpecialOneToOneType.assemble(Serializable oid,
SessionImplementor session,
Object owner) |
Object |
AbstractStandardBasicType.assemble(Serializable cached,
SessionImplementor session,
Object owner) |
Object |
ManyToOneType.assemble(Serializable oid,
SessionImplementor session,
Object owner) |
Object |
Type.assemble(Serializable cached,
SessionImplementor session,
Object owner)
Reconstruct the object from its cached "disassembled" state.
|
Object |
ComponentType.assemble(Serializable object,
SessionImplementor session,
Object owner) |
Object |
CollectionType.assemble(Serializable cached,
SessionImplementor session,
Object owner) |
Object |
StringClobType.deepCopy(Object value)
Deprecated.
|
Object |
EnumType.deepCopy(Object value) |
Object |
SerializableToBlobType.deepCopy(Object value,
EntityMode entityMode,
SessionFactoryImplementor factory) |
Object |
CustomType.deepCopy(Object value,
EntityMode entityMode,
SessionFactoryImplementor factory) |
Object |
MutableType.deepCopy(Object value,
EntityMode entityMode,
SessionFactoryImplementor factory)
Deprecated.
|
Object |
CompositeCustomType.deepCopy(Object value,
EntityMode entityMode,
SessionFactoryImplementor factory) |
Object |
AnyType.deepCopy(Object value,
EntityMode entityMode,
SessionFactoryImplementor factory) |
Object |
MetaType.deepCopy(Object value,
EntityMode entityMode,
SessionFactoryImplementor factory) |
Object |
Type.deepCopy(Object value,
EntityMode entityMode,
SessionFactoryImplementor factory)
Return a deep copy of the persistent state, stopping at entities and at
collections.
|
Object |
ComponentType.deepCopy(Object component,
EntityMode entityMode,
SessionFactoryImplementor factory) |
Object |
ByteArrayBlobType.deepCopy(Object value,
EntityMode entityMode,
SessionFactoryImplementor factory)
Deprecated.
|
Object |
CollectionType.deepCopy(Object value,
EntityMode entityMode,
SessionFactoryImplementor factory) |
protected abstract Object |
MutableType.deepCopyNotNull(Object value)
Deprecated.
|
protected Object |
AbstractCharArrayType.deepCopyNotNull(Object value)
Deprecated.
|
Serializable |
StringClobType.disassemble(Object value)
Deprecated.
|
Serializable |
EnumType.disassemble(Object value) |
Serializable |
OneToOneType.disassemble(Object value,
SessionImplementor session,
Object owner) |
Serializable |
AbstractType.disassemble(Object value,
SessionImplementor session,
Object owner) |
Serializable |
CustomType.disassemble(Object value,
SessionImplementor session,
Object owner) |
Serializable |
CompositeCustomType.disassemble(Object value,
SessionImplementor session,
Object owner) |
Serializable |
AnyType.disassemble(Object value,
SessionImplementor session,
Object owner) |
Serializable |
SpecialOneToOneType.disassemble(Object value,
SessionImplementor session,
Object owner) |
Serializable |
AbstractStandardBasicType.disassemble(Object value,
SessionImplementor session,
Object owner) |
Serializable |
ManyToOneType.disassemble(Object value,
SessionImplementor session,
Object owner) |
Serializable |
Type.disassemble(Object value,
SessionImplementor session,
Object owner)
Return a cacheable "disassembled" representation of the object.
|
Serializable |
ComponentType.disassemble(Object value,
SessionImplementor session,
Object owner) |
Serializable |
CollectionType.disassemble(Object value,
SessionImplementor session,
Object owner) |
boolean |
StringClobType.equals(Object x,
Object y)
Deprecated.
|
boolean |
EnumType.equals(Object x,
Object y) |
abstract Object |
NullableType.fromStringValue(String xml)
Deprecated.
|
Object |
AbstractBynaryType.fromStringValue(String xml)
Deprecated.
|
T |
StringRepresentableType.fromStringValue(String string)
Consume the given string representation back into this types java form.
|
T |
AbstractStandardBasicType.fromStringValue(String xml) |
Date |
TimestampType.fromStringValue(String xml) |
T |
SingleColumnType.fromStringValue(String xml) |
Object |
NullableType.fromXMLNode(org.dom4j.Node xml,
Mapping factory)
Deprecated.
|
Object |
SerializableToBlobType.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 |
CompositeCustomType.fromXMLNode(org.dom4j.Node xml,
Mapping factory) |
Object |
AnyType.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 |
NullableType.fromXMLString(String xml,
Mapping factory)
Deprecated.
|
T |
AbstractStandardBasicType.fromXMLString(String xml,
Mapping factory) |
T |
XmlRepresentableType.fromXMLString(String xml,
Mapping factory) |
Object |
MetaType.fromXMLString(String xml,
Mapping factory) |
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 |
AbstractLongStringType.get(ResultSet rs,
String name)
Deprecated.
|
Object |
AbstractBynaryType.get(ResultSet rs,
String name)
Deprecated.
|
Object |
AbstractSingleColumnStandardBasicType.get(ResultSet rs,
String name)
Deprecated.
|
Object |
SingleColumnType.get(ResultSet rs,
String name)
Deprecated.
|
Object |
AbstractStandardBasicType.get(ResultSet rs,
String name,
SessionImplementor session) |
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.
|
int |
Type.getHashCode(Object x,
EntityMode entityMode)
Get a hash code, consistent with persistence "equality".
|
int |
Type.getHashCode(Object x,
EntityMode entityMode,
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 |
AnyType.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[] |
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[] |
AnyType.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
|
int |
StringClobType.hashCode(Object x)
Deprecated.
|
int |
EnumType.hashCode(Object x) |
Object |
OneToOneType.hydrate(ResultSet rs,
String[] names,
SessionImplementor session,
Object owner) |
Object |
AbstractType.hydrate(ResultSet rs,
String[] names,
SessionImplementor session,
Object owner) |
Object |
AnyType.hydrate(ResultSet rs,
String[] names,
SessionImplementor session,
Object owner) |
Object |
SpecialOneToOneType.hydrate(ResultSet rs,
String[] names,
SessionImplementor session,
Object owner) |
Object |
AbstractStandardBasicType.hydrate(ResultSet rs,
String[] names,
SessionImplementor session,
Object owner) |
Object |
ManyToOneType.hydrate(ResultSet rs,
String[] names,
SessionImplementor session,
Object owner) |
Object |
Type.hydrate(ResultSet rs,
String[] names,
SessionImplementor session,
Object owner)
Retrieve an instance of the mapped class, or the identifier of an entity or collection,
from a JDBC resultset.
|
Object |
ComponentType.hydrate(ResultSet rs,
String[] names,
SessionImplementor session,
Object owner) |
Object |
ComponentType.instantiate(EntityMode entityMode)
This method does not populate the component parent
|
Object |
EmbeddedComponentType.instantiate(Object parent,
SessionImplementor session) |
Object |
ComponentType.instantiate(Object parent,
SessionImplementor session) |
PersistentCollection |
ArrayType.instantiate(SessionImplementor session,
CollectionPersister persister,
Serializable key) |
PersistentCollection |
CustomCollectionType.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) |
boolean |
NullableType.isDirty(Object old,
Object current,
boolean[] checkable,
SessionImplementor session)
Deprecated.
|
boolean |
CustomType.isDirty(Object old,
Object current,
boolean[] checkable,
SessionImplementor session) |
boolean |
AbstractLobType.isDirty(Object old,
Object current,
boolean[] checkable,
SessionImplementor session)
Deprecated.
|
boolean |
CompositeCustomType.isDirty(Object old,
Object current,
boolean[] checkable,
SessionImplementor session) |
boolean |
AnyType.isDirty(Object old,
Object current,
boolean[] checkable,
SessionImplementor session) |
boolean |
ManyToOneType.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 |
CollectionType.isDirty(Object old,
Object current,
boolean[] checkable,
SessionImplementor session) |
boolean |
AbstractType.isDirty(Object old,
Object current,
SessionImplementor session) |
boolean |
ManyToOneType.isDirty(Object old,
Object current,
SessionImplementor session) |
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 |
CollectionType.isDirty(Object old,
Object current,
SessionImplementor session) |
boolean |
CustomType.isEqual(Object x,
Object y) |
boolean |
CustomType.isEqual(Object x,
Object y,
EntityMode entityMode) |
boolean |
CompositeCustomType.isEqual(Object x,
Object y,
EntityMode entityMode) |
boolean |
Type.isEqual(Object x,
Object y,
EntityMode entityMode)
Compare two instances of the class mapped by this type for persistence "equality" (equality of persistent
state).
|
boolean |
ComponentType.isEqual(Object x,
Object y,
EntityMode entityMode) |
boolean |
Type.isEqual(Object x,
Object y,
EntityMode entityMode,
SessionFactoryImplementor factory)
Compare two instances of the class mapped by this type for persistence "equality" (equality of persistent
state).
|
boolean |
ComponentType.isEqual(Object x,
Object y,
EntityMode entityMode,
SessionFactoryImplementor factory) |
boolean |
AbstractType.isModified(Object old,
Object current,
boolean[] checkable,
SessionImplementor session) |
boolean |
AnyType.isModified(Object old,
Object current,
boolean[] checkable,
SessionImplementor session) |
boolean |
ManyToOneType.isModified(Object old,
Object current,
boolean[] checkable,
SessionImplementor session) |
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.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 |
CollectionType.isModified(Object old,
Object current,
boolean[] checkable,
SessionImplementor session) |
boolean |
AbstractType.isSame(Object x,
Object y,
EntityMode entityMode) |
boolean |
AnyType.isSame(Object x,
Object y,
EntityMode entityMode) |
boolean |
Type.isSame(Object x,
Object y,
EntityMode entityMode)
Compare two instances of the class mapped by this type for persistence "equality" (equality of persistent
state) taking a shortcut for entity references.
|
boolean |
ComponentType.isSame(Object x,
Object y,
EntityMode entityMode) |
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.
|
T |
AbstractSingleColumnStandardBasicType.nullSafeGet(ResultSet rs,
String name)
Deprecated.
|
T |
SingleColumnType.nullSafeGet(ResultSet rs,
String name)
Deprecated.
|
Object |
NullableType.nullSafeGet(ResultSet rs,
String[] names)
Deprecated.
|
Object |
StringClobType.nullSafeGet(ResultSet rs,
String[] names,
Object owner)
Deprecated.
|
Object |
EnumType.nullSafeGet(ResultSet rs,
String[] names,
Object owner) |
Object |
NullableType.nullSafeGet(ResultSet rs,
String[] names,
SessionImplementor session,
Object owner)
Deprecated.
|
Object |
CustomType.nullSafeGet(ResultSet rs,
String[] names,
SessionImplementor session,
Object owner) |
Object |
AbstractLobType.nullSafeGet(ResultSet rs,
String[] names,
SessionImplementor session,
Object owner)
Deprecated.
|
Object |
EntityType.nullSafeGet(ResultSet rs,
String[] names,
SessionImplementor session,
Object owner)
Retrieve an instance of the mapped class from a JDBC resultset.
|
Object |
CompositeCustomType.nullSafeGet(ResultSet rs,
String[] names,
SessionImplementor session,
Object owner) |
Object |
AnyType.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)
Retrieve an instance of the mapped class from a JDBC resultset.
|
Object |
ComponentType.nullSafeGet(ResultSet rs,
String[] names,
SessionImplementor session,
Object owner) |
Object |
CollectionType.nullSafeGet(ResultSet rs,
String[] name,
SessionImplementor session,
Object owner) |
T |
SingleColumnType.nullSafeGet(ResultSet rs,
String name,
SessionImplementor session)
Get a column value from a result set by name.
|
Object |
NullableType.nullSafeGet(ResultSet rs,
String name,
SessionImplementor session,
Object owner)
Deprecated.
|
Object |
CustomType.nullSafeGet(ResultSet rs,
String columnName,
SessionImplementor session,
Object owner) |
Object |
AbstractLobType.nullSafeGet(ResultSet rs,
String name,
SessionImplementor session,
Object owner)
Deprecated.
|
Object |
EntityType.nullSafeGet(ResultSet rs,
String name,
SessionImplementor session,
Object owner)
Retrieve an instance of the mapped class from a JDBC resultset.
|
Object |
CompositeCustomType.nullSafeGet(ResultSet rs,
String columnName,
SessionImplementor session,
Object owner) |
Object |
AnyType.nullSafeGet(ResultSet rs,
String name,
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)
Retrieve an instance of the mapped class from a JDBC resultset.
|
Object |
ComponentType.nullSafeGet(ResultSet rs,
String name,
SessionImplementor session,
Object owner) |
void |
StringClobType.nullSafeSet(PreparedStatement st,
Object value,
int index)
Deprecated.
|
void |
NullableType.nullSafeSet(PreparedStatement st,
Object value,
int index)
Deprecated.
|
void |
EnumType.nullSafeSet(PreparedStatement st,
Object value,
int index) |
void |
NullableType.nullSafeSet(PreparedStatement st,
Object value,
int index,
boolean[] settable,
SessionImplementor session)
Deprecated.
|
void |
CustomType.nullSafeSet(PreparedStatement st,
Object value,
int index,
boolean[] settable,
SessionImplementor session) |
void |
AbstractLobType.nullSafeSet(PreparedStatement st,
Object value,
int index,
boolean[] settable,
SessionImplementor session)
Deprecated.
|
void |
CompositeCustomType.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 |
AbstractSingleColumnStandardBasicType.nullSafeSet(PreparedStatement st,
Object value,
int index,
boolean[] settable,
SessionImplementor session)
Write an instance of the mapped class to a prepared statement, ignoring some columns.
|
void |
ManyToOneType.nullSafeSet(PreparedStatement st,
Object value,
int index,
boolean[] settable,
SessionImplementor session) |
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)
Write an instance of the mapped class to a prepared statement, ignoring some columns.
|
void |
ComponentType.nullSafeSet(PreparedStatement st,
Object value,
int begin,
boolean[] settable,
SessionImplementor session) |
void |
CollectionType.nullSafeSet(PreparedStatement st,
Object value,
int index,
boolean[] settable,
SessionImplementor session) |
void |
NullableType.nullSafeSet(PreparedStatement st,
Object value,
int index,
SessionImplementor session)
Deprecated.
|
void |
CustomType.nullSafeSet(PreparedStatement st,
Object value,
int index,
SessionImplementor session) |
void |
AbstractLobType.nullSafeSet(PreparedStatement st,
Object value,
int index,
SessionImplementor session)
Deprecated.
|
void |
CompositeCustomType.nullSafeSet(PreparedStatement st,
Object value,
int index,
SessionImplementor session) |
void |
AnyType.nullSafeSet(PreparedStatement st,
Object value,
int index,
SessionImplementor session) |
void |
ManyToOneType.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)
Write an instance of the mapped class to a prepared statement.
|
void |
ComponentType.nullSafeSet(PreparedStatement st,
Object value,
int begin,
SessionImplementor session) |
void |
CollectionType.nullSafeSet(PreparedStatement st,
Object value,
int index,
SessionImplementor session) |
void |
AbstractSingleColumnStandardBasicType.nullSafeSet(PreparedStatement st,
T value,
int index)
Deprecated.
|
void |
SingleColumnType.nullSafeSet(PreparedStatement st,
T value,
int index)
Deprecated.
|
String |
NullableType.nullSafeToString(Object value)
Deprecated.
A null-safe version of
NullableType.toString(Object) . |
protected String |
CustomCollectionType.renderLoggableString(Object value,
SessionFactoryImplementor factory) |
protected String |
CollectionType.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 |
SerializableToBlobType.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 |
MutableType.replace(Object original,
Object target,
SessionImplementor session,
Object owner,
Map copyCache)
Deprecated.
|
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 |
CompositeCustomType.replace(Object original,
Object target,
SessionImplementor session,
Object owner,
Map copyCache) |
Object |
ImmutableType.replace(Object original,
Object target,
SessionImplementor session,
Object owner,
Map copyCache)
Deprecated.
|
Object |
AnyType.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 |
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 |
AbstractType.replace(Object original,
Object target,
SessionImplementor session,
Object owner,
Map copyCache,
ForeignKeyDirection foreignKeyDirection) |
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 |
MapType.replaceElements(Object original,
Object target,
Object owner,
Map copyCache,
SessionImplementor session) |
Object |
ArrayType.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 |
AbstractType.resolve(Object value,
SessionImplementor session,
Object owner) |
Object |
EntityType.resolve(Object value,
SessionImplementor session,
Object owner)
Resolve an identifier or unique key value
|
Object |
AnyType.resolve(Object value,
SessionImplementor session,
Object owner) |
Object |
AbstractStandardBasicType.resolve(Object value,
SessionImplementor session,
Object owner) |
Object |
Type.resolve(Object value,
SessionImplementor session,
Object owner)
Map identifiers to entities or collections.
|
Object |
ComponentType.resolve(Object value,
SessionImplementor session,
Object owner) |
Object |
CollectionType.resolve(Object value,
SessionImplementor session,
Object owner) |
protected Object |
EntityType.resolveIdentifier(Serializable id,
SessionImplementor session)
Resolve an identifier via a load.
|
Object |
AbstractType.semiResolve(Object value,
SessionImplementor session,
Object owner) |
Object |
AnyType.semiResolve(Object value,
SessionImplementor session,
Object owner) |
Object |
AbstractStandardBasicType.semiResolve(Object value,
SessionImplementor session,
Object owner) |
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) |
abstract void |
NullableType.set(PreparedStatement st,
Object value,
int index)
Deprecated.
Set a parameter value without worrying about the possibility of null
values.
|
void |
AbstractLongStringType.set(PreparedStatement st,
Object value,
int index)
Deprecated.
|
void |
AbstractBynaryType.set(PreparedStatement st,
Object value,
int index)
Deprecated.
|
void |
AbstractSingleColumnStandardBasicType.set(PreparedStatement st,
T value,
int index)
Deprecated.
|
void |
SingleColumnType.set(PreparedStatement st,
T value,
int index)
Deprecated.
|
void |
AbstractStandardBasicType.set(PreparedStatement st,
T value,
int index,
SessionImplementor session) |
void |
SingleColumnType.set(PreparedStatement st,
T value,
int index,
SessionImplementor session)
Set a parameter value without worrying about the possibility of null
values.
|
void |
CompositeCustomType.setPropertyValues(Object component,
Object[] values,
EntityMode entityMode) |
void |
AnyType.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 |
NullableType.setToXMLNode(org.dom4j.Node xml,
Object value,
SessionFactoryImplementor factory)
Deprecated.
|
void |
SerializableToBlobType.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 |
CompositeCustomType.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) |
String |
ArrayType.toLoggableString(Object value,
SessionFactoryImplementor factory) |
String |
SerializableToBlobType.toLoggableString(Object value,
SessionFactoryImplementor factory) |
String |
CustomType.toLoggableString(Object value,
SessionFactoryImplementor factory) |
String |
CompositeCustomType.toLoggableString(Object value,
SessionFactoryImplementor factory) |
String |
AnyType.toLoggableString(Object value,
SessionFactoryImplementor factory) |
String |
MetaType.toLoggableString(Object value,
SessionFactoryImplementor factory) |
String |
Type.toLoggableString(Object value,
SessionFactoryImplementor factory)
A representation of the value to be embedded in a log file.
|
String |
ComponentType.toLoggableString(Object value,
SessionFactoryImplementor factory) |
String |
CollectionType.toLoggableString(Object value,
SessionFactoryImplementor factory) |
abstract String |
NullableType.toString(Object value)
Deprecated.
|
String |
StringRepresentableType.toString(T value)
Render the value to the string representation.
|
String |
SingleColumnType.toString(T value) |
String |
NullableType.toXMLString(Object value,
SessionFactoryImplementor pc)
Deprecated.
|
String |
MetaType.toXMLString(Object value,
SessionFactoryImplementor factory) |
String |
AbstractStandardBasicType.toXMLString(T value,
SessionFactoryImplementor factory) |
String |
XmlRepresentableType.toXMLString(T value,
SessionFactoryImplementor factory) |
Modifier and Type | Method and Description |
---|---|
protected HibernateException |
AbstractTypeDescriptor.unknownUnwrap(Class conversionType) |
protected HibernateException |
AbstractTypeDescriptor.unknownWrap(Class conversionType) |
Modifier and Type | Method and Description |
---|---|
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,
Object owner)
Deprecated.
SessionImplementor will be added as an argument in a future version (see HHH-5968)
|
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)
Deprecated.
SessionImplementor will be added as an argument in a future version (see HHH-5968)
|
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.
|
Modifier and Type | Method and Description |
---|---|
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 |
Cloneable.validate()
Checks to ensure the SessionEventListenerConfig is fully
configured (basically, that none of the listeners is null).
|
Copyright © 2002-2017 Red Hat Middleware, LLC. All Rights Reserved