Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.hibernate
Interface Session

All Superinterfaces:
  Serializable

All Known Subinterfaces:
  EventSource, Session

All Known Implementing Classes:
  SessionImpl

    public interface Session

extends Serializable

The main runtime interface between a Java application and Hibernate. This is the central API class abstracting the notion of a persistence service.
The lifecycle of a `Session` is bounded by the beginning and end of a logical transaction. (Long transactions might span several database transactions.)
The main function of the `Session` is to offer create, read and delete operations for instances of mapped entity classes. Instances may exist in one of three states:
transient: never persistent, not associated with any `Session`
persistent: associated with a unique `Session`
detached: previously persistent, not associated with any `Session`
Transient instances may be made persistent by calling `save()`, `persist()` or `saveOrUpdate()`. Persistent instances may be made transient by calling`delete()`. Any instance returned by a `get()` or `load()` method is persistent. Detached instances may be made persistent by calling `update()`, `saveOrUpdate()`, `lock()` or `replicate()`. The state of a transient or detached instance may also be made persistent as a new persistent instance by calling `merge()`.
`save()` and `persist()` result in an SQL `INSERT`, `delete()` in an SQL `DELETE` and `update()` or `merge()` in an SQL `UPDATE`. Changes to persistent instances are detected at flush time and also result in an SQL `UPDATE`. `saveOrUpdate()` and `replicate()` result in either an `INSERT` or an `UPDATE`.
It is not intended that implementors be threadsafe. Instead each thread/transaction should obtain its own instance from a `SessionFactory`.
A `Session` instance is serializable if its persistent classes are serializable.
A typical transaction should use the following idiom:

     Session sess = factory.openSession();
     Transaction tx;
     try {
         tx = sess.beginTransaction();
         //do some work
         ...
         tx.commit();
     }
     catch (Exception e) {
         if (tx!=null) tx.rollback();
         throw e;
     }
     finally {
         sess.close();
     }

If the `Session` throws an exception, the transaction must be rolled back and the session discarded. The internal state of the `Session` might not be consistent with the database after the exception occurs.

Author:
  Gavin King
See Also:
  `SessionFactory`

Method Summary
`Transaction` | `beginTransaction()` Begin a unit of work and return the associated `Transaction` object.
`void` | `cancelQuery()` Cancel the execution of the current query.
`void` | `clear()` Completely clear the session.
`Connection` | `close()` End the session by releasing the JDBC connection and cleaning up.
`Connection` | `connection()` Deprecated. To be replaced with a SPI for performing work against the connection; scheduled for removal in 4.x
`boolean` | `contains(Object object)` Check if this instance is associated with this `Session`.
`Criteria` | `createCriteria(Class persistentClass)` Create a new `Criteria` instance, for the given entity class, or a superclass of an entity class.
`Criteria` | `createCriteria(Class persistentClass, String alias)` Create a new `Criteria` instance, for the given entity class, or a superclass of an entity class, with the given alias.
`Criteria` | `createCriteria(String entityName)` Create a new `Criteria` instance, for the given entity name.
`Criteria` | `createCriteria(String entityName, String alias)` Create a new `Criteria` instance, for the given entity name, with the given alias.
`Query` | `createFilter(Object collection, String queryString)` Create a new instance of `Query` for the given collection and filter string.
`Query` | `createQuery(String queryString)` Create a new instance of `Query` for the given HQL query string.
`SQLQuery` | `createSQLQuery(String queryString)` Create a new instance of `SQLQuery` for the given SQL query string.
`void` | `delete(Object object)` Remove a persistent instance from the datastore.
`void` | `delete(String entityName, Object object)` Remove a persistent instance from the datastore.
`void` | `disableFilter(String filterName)` Disable the named filter for the current session.
`Connection` | `disconnect()` Disconnect the `Session` from the current JDBC connection.
`Filter` | `enableFilter(String filterName)` Enable the named filter for this current session.
`void` | `evict(Object object)` Remove this instance from the session cache.
`void` | `flush()` Force this session to flush.
`Object` | `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` | `get(Class clazz, Serializable id, LockMode lockMode)` Return the persistent instance of the given entity class with the given identifier, or null if there is no such persistent instance.
`Object` | `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` | `get(String entityName, Serializable id, LockMode lockMode)` Return the persistent instance of the given entity class with the given identifier, or null if there is no such persistent instance.
`CacheMode` | `getCacheMode()` Get the current cache mode.
`LockMode` | `getCurrentLockMode(Object object)` Determine the current lock mode of the given object.
`Filter` | `getEnabledFilter(String filterName)` Retrieve a currently enabled filter by name.
`EntityMode` | `getEntityMode()` Retrieve the entity mode in effect for this session.
`String` | `getEntityName(Object object)` Return the entity name for a persistent entity
`FlushMode` | `getFlushMode()` Get the current flush mode for this session.
`Serializable` | `getIdentifier(Object object)` Return the identifier value of the given entity as associated with this session.
`Query` | `getNamedQuery(String queryName)` Obtain an instance of `Query` for a named query string defined in the mapping file.
`Session` | `getSession(EntityMode entityMode)` Starts a new Session with the given entity mode in effect.
`SessionFactory` | `getSessionFactory()` Get the session factory which created this session.
`SessionStatistics` | `getStatistics()` Get the statistics for this session.
`Transaction` | `getTransaction()` Get the `Transaction` instance associated with this session.
`boolean` | `isConnected()` Check if the session is currently connected.
`boolean` | `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` | `isOpen()` Check if the session is still open.
`Object` | `load(Class theClass, Serializable id)` Return the persistent instance of the given entity class with the given identifier, assuming that the instance exists.
`Object` | `load(Class theClass, Serializable id, LockMode lockMode)` Return the persistent instance of the given entity class with the given identifier, obtaining the specified lock mode, assuming the instance exists.
`void` | `load(Object object, Serializable id)` Read the persistent state associated with the given identifier into the given transient instance.
`Object` | `load(String entityName, Serializable id)` Return the persistent instance of the given entity class with the given identifier, assuming that the instance exists.
`Object` | `load(String entityName, Serializable id, LockMode lockMode)` Return the persistent instance of the given entity class with the given identifier, obtaining the specified lock mode, assuming the instance exists.
`void` | `lock(Object object, LockMode lockMode)` Obtain the specified lock level upon the given object.
`void` | `lock(String entityName, Object object, LockMode lockMode)` Obtain the specified lock level upon the given object.
`Object` | `merge(Object object)` Copy the state of the given object onto the persistent object with the same identifier.
`Object` | `merge(String entityName, Object object)` Copy the state of the given object onto the persistent object with the same identifier.
`void` | `persist(Object object)` Make a transient instance persistent.
`void` | `persist(String entityName, Object object)` Make a transient instance persistent.
`void` | `reconnect()` Deprecated. Manual reconnection is only needed in the case of application-supplied connections, in which case the `reconnect(java.sql.Connection)` for should be used.
`void` | `reconnect(Connection connection)` Reconnect to the given JDBC connection.
`void` | `refresh(Object object)` Re-read the state of the given instance from the underlying database.
`void` | `refresh(Object object, LockMode lockMode)` Re-read the state of the given instance from the underlying database, with the given `LockMode`.
`void` | `replicate(Object object, ReplicationMode replicationMode)` Persist the state of the given detached instance, reusing the current identifier value.
`void` | `replicate(String entityName, Object object, ReplicationMode replicationMode)` Persist the state of the given detached instance, reusing the current identifier value.
`Serializable` | `save(Object object)` Persist the given transient instance, first assigning a generated identifier.
`Serializable` | `save(String entityName, Object object)` Persist the given transient instance, first assigning a generated identifier.
`void` | `saveOrUpdate(Object object)` Either `save(Object)` or `update(Object)` the given instance, depending upon resolution of the unsaved-value checks (see the manual for discussion of unsaved-value checking).
`void` | `saveOrUpdate(String entityName, Object object)` Either `save(String, Object)` or `update(String, Object)` the given instance, depending upon resolution of the unsaved-value checks (see the manual for discussion of unsaved-value checking).
`void` | `setCacheMode(CacheMode cacheMode)` Set the cache mode.
`void` | `setFlushMode(FlushMode flushMode)` Set the flush mode for this session.
`void` | `setReadOnly(Object entity, boolean readOnly)` Set an unmodified persistent object to read only mode, or a read only object to modifiable mode.
`void` | `update(Object object)` Update the persistent instance with the identifier of the given detached instance.
`void` | `update(String entityName, Object object)` Update the persistent instance with the identifier of the given detached instance.

Method Detail

### getEntityMode

    EntityMode getEntityMode()

  Retrieve the entity mode in effect for this session.

  Returns:
    The entity mode for this session.

### getSession

    Session getSession(EntityMode entityMode)

  Starts a new Session with the given entity mode in effect. This secondary Session inherits the connection, transaction, and other context information from the primary Session. It doesn't need to be flushed or closed by the developer.

  Parameters:
    `entityMode` - The entity mode to use for the new session.
  Returns:
    The new session

### flush

    void flush()
               throws HibernateException

  Force this session to flush. Must be called at the end of a unit of work, before commiting the transaction and closing the session (depending on `flush-mode`, `Transaction.commit()` calls this method).

  Flushing is the process of synchronizing the underlying persistent store with persistable state held in memory.

  Throws:
    `HibernateException` - Indicates problems flushing the session or talking to the database.

### setFlushMode

    void setFlushMode(FlushMode flushMode)

  Set the flush mode for this session.

  The flush mode determines the points at which the session is flushed. Flushing is the process of synchronizing the underlying persistent store with persistable state held in memory.

  For a logically "read only" session, it is reasonable to set the session's flush mode to `FlushMode.MANUAL` at the start of the session (in order to achieve some extra performance).

  Parameters:
    `flushMode` - the new flush mode
  See Also:
    `FlushMode`

### getFlushMode

    FlushMode getFlushMode()

  Get the current flush mode for this session.

  Returns:
    The flush mode

### setCacheMode

    void setCacheMode(CacheMode cacheMode)

  Set the cache mode.

  Cache mode determines the manner in which this session can interact with the second level cache.

  Parameters:
    `cacheMode` - The new cache mode.

### getCacheMode

    CacheMode getCacheMode()

  Get the current cache mode.

  Returns:
    The current cache mode.

### getSessionFactory

    SessionFactory getSessionFactory()

  Get the session factory which created this session.

  Returns:
    The session factory.
  See Also:
    `SessionFactory`

### connection

    Connection connection()
                          throws HibernateException

  Deprecated. To be replaced with a SPI for performing work against the connection; scheduled for removal in 4.x

  Get the JDBC connection of this Session.
  If the session is using aggressive collection release (as in a CMT environment), it is the application's responsibility to close the connection returned by this call. Otherwise, the application should not close the connection.

  Returns:
    the JDBC connection in use by the `Session`
  Throws:
    `HibernateException` - if the `Session` is disconnected

### close

    Connection close()
                     throws HibernateException

  End the session by releasing the JDBC connection and cleaning up. It is not strictly necessary to close the session but you must at least `disconnect()` it.

  Returns:
    the connection provided by the application or null.
  Throws:
    `HibernateException` - Indicates problems cleaning up.

### cancelQuery

    void cancelQuery()
                     throws HibernateException

  Cancel the execution of the current query.

  This is the sole method on session which may be safely called from another thread.

  Throws:
    `HibernateException` - There was a problem canceling the query

### isOpen

    boolean isOpen()

  Check if the session is still open.

  Returns:
    boolean

### isConnected

    boolean isConnected()

  Check if the session is currently connected.

  Returns:
    boolean

### isDirty

    boolean isDirty()
                    throws HibernateException

  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?

  Returns:
    True if the session contains pending changes; false otherwise.
  Throws:
    `HibernateException` - could not perform dirtying checking

### getIdentifier

    Serializable getIdentifier(Object object)
                               throws HibernateException

  Return the identifier value of the given entity as associated with this session. An exception is thrown if the given entity instance is transient or detached in relation to this session.

  Parameters:
    `object` - a persistent instance
  Returns:
    the identifier
  Throws:
    `TransientObjectException` - if the instance is transient or associated with a different session
    `HibernateException`

### contains

    boolean contains(Object object)

  Check if this instance is associated with this `Session`.

  Parameters:
    `object` - an instance of a persistent class
  Returns:
    true if the given instance is associated with this `Session`

### evict

    void evict(Object object)
               throws HibernateException

  Remove this instance from the session cache. Changes to the instance will not be synchronized with the database. This operation cascades to associated instances if the association is mapped with `cascade="evict"`.

  Parameters:
    `object` - a persistent instance
  Throws:
    `HibernateException`

### load

    Object load(Class theClass,
                Serializable id,
                LockMode lockMode)
                throws HibernateException

  Return the persistent instance of the given entity class with the given identifier, obtaining the specified lock mode, assuming the instance exists.

  Parameters:
    `theClass` - a persistent class
    `id` - a valid identifier of an existing persistent instance of the class
    `lockMode` - the lock level
  Returns:
    the persistent instance or proxy
  Throws:
    `HibernateException`

### load

    Object load(String entityName,
                Serializable id,
                LockMode lockMode)
                throws HibernateException

  Return the persistent instance of the given entity class with the given identifier, obtaining the specified lock mode, assuming the instance exists.

  Parameters:
    `entityName` - a persistent class
    `id` - a valid identifier of an existing persistent instance of the class
    `lockMode` - the lock level
  Returns:
    the persistent instance or proxy
  Throws:
    `HibernateException`

### load

    Object load(Class theClass,
                Serializable id)
                throws HibernateException

  Return the persistent instance of the given entity class with the given identifier, assuming that the instance exists.
  You should not use this method to determine if an instance exists (use `get()` instead). Use this only to retrieve an instance that you assume exists, where non-existence would be an actual error.

  Parameters:
    `theClass` - a persistent class
    `id` - a valid identifier of an existing persistent instance of the class
  Returns:
    the persistent instance or proxy
  Throws:
    `HibernateException`

### load

    Object load(String entityName,
                Serializable id)
                throws HibernateException

  Return the persistent instance of the given entity class with the given identifier, assuming that the instance exists.
  You should not use this method to determine if an instance exists (use `get()` instead). Use this only to retrieve an instance that you assume exists, where non-existence would be an actual error.

  Parameters:
    `entityName` - a persistent class
    `id` - a valid identifier of an existing persistent instance of the class
  Returns:
    the persistent instance or proxy
  Throws:
    `HibernateException`

### load

    void load(Object object,
              Serializable id)
              throws HibernateException

  Read the persistent state associated with the given identifier into the given transient instance.

  Parameters:
    `object` - an "empty" instance of the persistent class
    `id` - a valid identifier of an existing persistent instance of the class
  Throws:
    `HibernateException`

### replicate

    void replicate(Object object,
                   ReplicationMode replicationMode)
                   throws HibernateException

  Persist the state of the given detached instance, reusing the current identifier value. This operation cascades to associated instances if the association is mapped with `cascade="replicate"`.

  Parameters:
    `object` - a detached instance of a persistent class
  Throws:
    `HibernateException`

### replicate

    void replicate(String entityName,
                   Object object,
                   ReplicationMode replicationMode)
                   throws HibernateException

  Persist the state of the given detached instance, reusing the current identifier value. This operation cascades to associated instances if the association is mapped with `cascade="replicate"`.

  Parameters:
    `object` - a detached instance of a persistent class
  Throws:
    `HibernateException`

### save

    Serializable save(Object object)
                      throws HibernateException

  Persist the given transient instance, first assigning a generated identifier. (Or using the current value of the identifier property if the `assigned` generator is used.) This operation cascades to associated instances if the association is mapped with `cascade="save-update"`.

  Parameters:
    `object` - a transient instance of a persistent class
  Returns:
    the generated identifier
  Throws:
    `HibernateException`

### save

    Serializable save(String entityName,
                      Object object)
                      throws HibernateException

  Persist the given transient instance, first assigning a generated identifier. (Or using the current value of the identifier property if the `assigned` generator is used.) This operation cascades to associated instances if the association is mapped with `cascade="save-update"`.

  Parameters:
    `object` - a transient instance of a persistent class
  Returns:
    the generated identifier
  Throws:
    `HibernateException`

### saveOrUpdate

    void saveOrUpdate(Object object)
                      throws HibernateException

  Either `save(Object)` or `update(Object)` the given instance, depending upon resolution of the unsaved-value checks (see the manual for discussion of unsaved-value checking).

  This operation cascades to associated instances if the association is mapped with `cascade="save-update"`.

  Parameters:
    `object` - a transient or detached instance containing new or updated state
  Throws:
    `HibernateException`
  See Also:
    `save(Object)`, `update(Object)`

### saveOrUpdate

    void saveOrUpdate(String entityName,
                      Object object)
                      throws HibernateException

  Either `save(String, Object)` or `update(String, Object)` the given instance, depending upon resolution of the unsaved-value checks (see the manual for discussion of unsaved-value checking).

  This operation cascades to associated instances if the association is mapped with `cascade="save-update"`.

  Parameters:
    `entityName` - The name of the entity
    `object` - a transient or detached instance containing new or updated state
  Throws:
    `HibernateException`
  See Also:
    `save(String,Object)`, `update(String,Object)`

### update

    void update(Object object)
                throws HibernateException

  Update the persistent instance with the identifier of the given detached instance. If there is a persistent instance with the same identifier, an exception is thrown. This operation cascades to associated instances if the association is mapped with `cascade="save-update"`.

  Parameters:
    `object` - a detached instance containing updated state
  Throws:
    `HibernateException`

### update

    void update(String entityName,
                Object object)
                throws HibernateException

  Update the persistent instance with the identifier of the given detached instance. If there is a persistent instance with the same identifier, an exception is thrown. This operation cascades to associated instances if the association is mapped with `cascade="save-update"`.

  Parameters:
    `object` - a detached instance containing updated state
  Throws:
    `HibernateException`

### merge

    Object merge(Object object)
                 throws HibernateException

  Copy the state of the given object onto the persistent object with the same identifier. If there is no persistent instance currently associated with the session, it will be loaded. Return the persistent instance. If the given instance is unsaved, save a copy of and return it as a newly persistent instance. The given instance does not become associated with the session. This operation cascades to associated instances if the association is mapped with `cascade="merge"`.
  The semantics of this method are defined by JSR-220.

  Parameters:
    `object` - a detached instance with state to be copied
  Returns:
    an updated persistent instance
  Throws:
    `HibernateException`

### merge

    Object merge(String entityName,
                 Object object)
                 throws HibernateException

  Copy the state of the given object onto the persistent object with the same identifier. If there is no persistent instance currently associated with the session, it will be loaded. Return the persistent instance. If the given instance is unsaved, save a copy of and return it as a newly persistent instance. The given instance does not become associated with the session. This operation cascades to associated instances if the association is mapped with `cascade="merge"`.
  The semantics of this method are defined by JSR-220.

  Parameters:
    `object` - a detached instance with state to be copied
  Returns:
    an updated persistent instance
  Throws:
    `HibernateException`

### persist

    void persist(Object object)
                 throws HibernateException

  Make a transient instance persistent. This operation cascades to associated instances if the association is mapped with `cascade="persist"`.
  The semantics of this method are defined by JSR-220.

  Parameters:
    `object` - a transient instance to be made persistent
  Throws:
    `HibernateException`

### persist

    void persist(String entityName,
                 Object object)
                 throws HibernateException

  Make a transient instance persistent. This operation cascades to associated instances if the association is mapped with `cascade="persist"`.
  The semantics of this method are defined by JSR-220.

  Parameters:
    `object` - a transient instance to be made persistent
  Throws:
    `HibernateException`

### delete

    void delete(Object object)
                throws HibernateException

  Remove a persistent instance from the datastore. The argument may be an instance associated with the receiving `Session` or a transient instance with an identifier associated with existing persistent state. This operation cascades to associated instances if the association is mapped with `cascade="delete"`.

  Parameters:
    `object` - the instance to be removed
  Throws:
    `HibernateException`

### delete

    void delete(String entityName,
                Object object)
                throws HibernateException

  Remove a persistent instance from the datastore. The object argument may be an instance associated with the receiving `Session` or a transient instance with an identifier associated with existing persistent state. This operation cascades to associated instances if the association is mapped with `cascade="delete"`.

  Parameters:
    `entityName` - The entity name for the instance to be removed.
    `object` - the instance to be removed
  Throws:
    `HibernateException`

### lock

    void lock(Object object,
              LockMode lockMode)
              throws HibernateException

  Obtain the specified lock level upon the given object. This may be used to perform a version check (`LockMode.READ`), to upgrade to a pessimistic lock (`LockMode.UPGRADE`), or to simply reassociate a transient instance with a session (`LockMode.NONE`). This operation cascades to associated instances if the association is mapped with `cascade="lock"`.

  Parameters:
    `object` - a persistent or transient instance
    `lockMode` - the lock level
  Throws:
    `HibernateException`

### lock

    void lock(String entityName,
              Object object,
              LockMode lockMode)
              throws HibernateException

  Obtain the specified lock level upon the given object. This may be used to perform a version check (`LockMode.READ`), to upgrade to a pessimistic lock (`LockMode.UPGRADE`), or to simply reassociate a transient instance with a session (`LockMode.NONE`). This operation cascades to associated instances if the association is mapped with `cascade="lock"`.

  Parameters:
    `object` - a persistent or transient instance
    `lockMode` - the lock level
  Throws:
    `HibernateException`

### refresh

    void refresh(Object object)
                 throws HibernateException

  Re-read the state of the given instance from the underlying database. It is inadvisable to use this to implement long-running sessions that span many business tasks. This method is, however, useful in certain special circumstances. For example
  - where a database trigger alters the object state upon insert or update
  - after executing direct SQL (eg. a mass update) in the same session
  - after inserting a `Blob` or `Clob`

  Parameters:
    `object` - a persistent or detached instance
  Throws:
    `HibernateException`

### refresh

    void refresh(Object object,
                 LockMode lockMode)
                 throws HibernateException

  Re-read the state of the given instance from the underlying database, with the given `LockMode`. It is inadvisable to use this to implement long-running sessions that span many business tasks. This method is, however, useful in certain special circumstances.

  Parameters:
    `object` - a persistent or detached instance
    `lockMode` - the lock mode to use
  Throws:
    `HibernateException`

### getCurrentLockMode

    LockMode getCurrentLockMode(Object object)
                                throws HibernateException

  Determine the current lock mode of the given object.

  Parameters:
    `object` - a persistent instance
  Returns:
    the current lock mode
  Throws:
    `HibernateException`

### beginTransaction

    Transaction beginTransaction()
                                 throws HibernateException

  Begin a unit of work and return the associated `Transaction` object. If a new underlying transaction is required, begin the transaction. Otherwise continue the new work in the context of the existing underlying transaction. The class of the returned `Transaction` object is determined by the property `hibernate.transaction_factory`.

  Returns:
    a Transaction instance
  Throws:
    `HibernateException`
  See Also:
    `Transaction`

### getTransaction

    Transaction getTransaction()

  Get the `Transaction` instance associated with this session. The class of the returned `Transaction` object is determined by the property `hibernate.transaction_factory`.

  Returns:
    a Transaction instance
  Throws:
    `HibernateException`
  See Also:
    `Transaction`

### createCriteria

    Criteria createCriteria(Class persistentClass)

  Create a new `Criteria` instance, for the given entity class, or a superclass of an entity class.

  Parameters:
    `persistentClass` - a class, which is persistent, or has persistent subclasses
  Returns:
    Criteria

### createCriteria

    Criteria createCriteria(Class persistentClass,
                            String alias)

  Create a new `Criteria` instance, for the given entity class, or a superclass of an entity class, with the given alias.

  Parameters:
    `persistentClass` - a class, which is persistent, or has persistent subclasses
  Returns:
    Criteria

### createCriteria

    Criteria createCriteria(String entityName)

  Create a new `Criteria` instance, for the given entity name.

  Parameters:
    `entityName` -
  Returns:
    Criteria

### createCriteria

    Criteria createCriteria(String entityName,
                            String alias)

  Create a new `Criteria` instance, for the given entity name, with the given alias.

  Parameters:
    `entityName` -
  Returns:
    Criteria

### createQuery

    Query createQuery(String queryString)
                      throws HibernateException

  Create a new instance of `Query` for the given HQL query string.

  Parameters:
    `queryString` - a HQL query
  Returns:
    Query
  Throws:
    `HibernateException`

### createSQLQuery

    SQLQuery createSQLQuery(String queryString)
                            throws HibernateException

  Create a new instance of `SQLQuery` for the given SQL query string.

  Parameters:
    `queryString` - a SQL query
  Returns:
    SQLQuery
  Throws:
    `HibernateException`

### createFilter

    Query createFilter(Object collection,
                       String queryString)
                       throws HibernateException

  Create a new instance of `Query` for the given collection and filter string.

  Parameters:
    `collection` - a persistent collection
    `queryString` - a Hibernate query
  Returns:
    Query
  Throws:
    `HibernateException`

### getNamedQuery

    Query getNamedQuery(String queryName)
                        throws HibernateException

  Obtain an instance of `Query` for a named query string defined in the mapping file.

  Parameters:
    `queryName` - the name of a query defined externally
  Returns:
    Query
  Throws:
    `HibernateException`

### clear

    void clear()

  Completely clear the session. Evict all loaded instances and cancel all pending saves, updates and deletions. Do not close open iterators or instances of `ScrollableResults`.

### get

    Object get(Class clazz,
               Serializable id)
               throws HibernateException

  Return the persistent instance of the given entity class with the given identifier, or null if there is no such persistent instance. (If the instance, or a proxy for the instance, is already associated with the session, return that instance or proxy.)

  Parameters:
    `clazz` - a persistent class
    `id` - an identifier
  Returns:
    a persistent instance or null
  Throws:
    `HibernateException`

### get

    Object get(Class clazz,
               Serializable id,
               LockMode lockMode)
               throws HibernateException

  Return the persistent instance of the given entity class with the given identifier, or null if there is no such persistent instance. Obtain the specified lock mode if the instance exists.

  Parameters:
    `clazz` - a persistent class
    `id` - an identifier
    `lockMode` - the lock mode
  Returns:
    a persistent instance or null
  Throws:
    `HibernateException`

### get

    Object get(String entityName,
               Serializable id)
               throws HibernateException

  Return the persistent instance of the given named entity with the given identifier, or null if there is no such persistent instance. (If the instance, or a proxy for the instance, is already associated with the session, return that instance or proxy.)

  Parameters:
    `entityName` - the entity name
    `id` - an identifier
  Returns:
    a persistent instance or null
  Throws:
    `HibernateException`

### get

    Object get(String entityName,
               Serializable id,
               LockMode lockMode)
               throws HibernateException

  Return the persistent instance of the given entity class with the given identifier, or null if there is no such persistent instance. Obtain the specified lock mode if the instance exists.

  Parameters:
    `entityName` - the entity name
    `id` - an identifier
    `lockMode` - the lock mode
  Returns:
    a persistent instance or null
  Throws:
    `HibernateException`

### getEntityName

    String getEntityName(Object object)
                         throws HibernateException

  Return the entity name for a persistent entity

  Parameters:
    `object` - a persistent entity
  Returns:
    the entity name
  Throws:
    `HibernateException`

### enableFilter

    Filter enableFilter(String filterName)

  Enable the named filter for this current session.

  Parameters:
    `filterName` - The name of the filter to be enabled.
  Returns:
    The Filter instance representing the enabled fiter.

### getEnabledFilter

    Filter getEnabledFilter(String filterName)

  Retrieve a currently enabled filter by name.

  Parameters:
    `filterName` - The name of the filter to be retrieved.
  Returns:
    The Filter instance representing the enabled fiter.

### disableFilter

    void disableFilter(String filterName)

  Disable the named filter for the current session.

  Parameters:
    `filterName` - The name of the filter to be disabled.

### getStatistics

    SessionStatistics getStatistics()

  Get the statistics for this session.

### setReadOnly

    void setReadOnly(Object entity,
                     boolean readOnly)

  Set an unmodified persistent object to read only mode, or a read only object to modifiable mode. In read only mode, no snapshot is maintained and the instance is never dirty checked.

  See Also:
    `Query.setReadOnly(boolean)`

### disconnect

    Connection disconnect()
                          throws HibernateException

  Disconnect the `Session` from the current JDBC connection. If the connection was obtained by Hibernate close it and return it to the connection pool; otherwise, return it to the application.

  This is used by applications which supply JDBC connections to Hibernate and which require long-sessions (or long-conversations)

  Note that disconnect() called on a session where the connection was retrieved by Hibernate through its configured `ConnectionProvider` has no effect, provided `ConnectionReleaseMode.ON_CLOSE` is not in effect.

  Returns:
    the application-supplied connection or `null`
  Throws:
    `HibernateException`
  See Also:
    `reconnect(Connection)`, `reconnect()`

### reconnect

    void reconnect()
                   throws HibernateException

  Deprecated. Manual reconnection is only needed in the case of application-supplied connections, in which case the `reconnect(java.sql.Connection)` for should be used.

  Obtain a new JDBC connection. This is used by applications which require long transactions and do not supply connections to the session.

  Throws:
    `HibernateException`
  See Also:
    `disconnect()`

### reconnect

    void reconnect(Connection connection)
                   throws HibernateException

  Reconnect to the given JDBC connection. This is used by applications which require long transactions and use application-supplied connections.

  Parameters:
    `connection` - a JDBC connection
  Throws:
    `HibernateException`
  See Also:
    `disconnect()`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD