AbstractEntityManagerImpl (JBoss Application Server: Build 7.1.2.Final API)

java.lang.Object
- org.hibernate.ejb.AbstractEntityManagerImpl

All Implemented Interfaces:

Serializable, EntityManager, HibernateEntityManager, HibernateEntityManagerImplementor

Direct Known Subclasses:

EntityManagerImpl
```
public abstract class AbstractEntityManagerImpl
extends Object
implements HibernateEntityManagerImplementor, Serializable
```
Author:

Gavin King, Emmanuel Bernard, Steve Ebersole, Hardy Ferentschik

See Also:
Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class AbstractEntityManagerImpl.TupleBuilderTransformer
- Nested classes/interfaces inherited from interface org.hibernate.ejb.HibernateEntityManagerImplementor
  HibernateEntityManagerImplementor.Options

Nested Classes
Modifier and Type	Class and Description
`static class`	`AbstractEntityManagerImpl.TupleBuilderTransformer`

Field Summary

Fields
Modifier and Type Field and Description

protected PersistenceContextType persistenceContextType

protected TransactionImpl tx

Fields
Modifier and Type	Field and Description
`protected PersistenceContextType`	`persistenceContextType`
`protected TransactionImpl`	`tx`

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`AbstractEntityManagerImpl(EntityManagerFactoryImpl entityManagerFactory, PersistenceContextType type, PersistenceUnitTransactionType transactionType, Map properties)`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`clear()` Clear the persistence context, causing all managed entities to become detached.
`boolean`	`contains(Object entity)` Check if the instance is a managed entity instance belonging to the current persistence context.
`RuntimeException`	`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`	`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`	`convert(RuntimeException e)`
`Query`	`createNamedQuery(String name)` Create an instance of `Query` for executing a named query (in the Java Persistence query language or in native SQL).
`<T> TypedQuery<T>`	`createNamedQuery(String name, Class<T> resultClass)` Create an instance of `TypedQuery` for executing a Java Persistence query language named query.
`Query`	`createNativeQuery(String sqlString)` Create an instance of `Query` for executing a native SQL statement, e.g., for update or delete.
`Query`	`createNativeQuery(String sqlString, Class resultClass)` Create an instance of `Query` for executing a native SQL query.
`Query`	`createNativeQuery(String sqlString, String resultSetMapping)` Create an instance of `Query` for executing a native SQL query.
`<T> TypedQuery<T>`	`createQuery(CriteriaQuery<T> criteriaQuery)` Create an instance of `TypedQuery` for executing a criteria query.
`Query`	`createQuery(String jpaqlString)` Create an instance of `Query` for executing a Java Persistence query language statement.
`<T> TypedQuery<T>`	`createQuery(String jpaqlString, Class<T> resultClass)` Create an instance of `TypedQuery` for executing a Java Persistence query language statement.
`<T> TypedQuery<T>`	`createQuery(String jpaqlString, Class<T> resultClass, Selection selection, HibernateEntityManagerImplementor.Options options)` Used during "compiling" a JPA criteria query.
`void`	`detach(Object entity)` Remove the given entity from the persistence context, causing a managed entity to become detached.
`CacheMode`	`determineAppropriateLocalCacheMode(Map<String,Object> localProperties)`
`<A> A`	`find(Class<A> entityClass, Object primaryKey)` Find by primary key.
`<A> A`	`find(Class<A> entityClass, Object primaryKey, LockModeType lockModeType)` Find by primary key and lock.
`<A> A`	`find(Class<A> entityClass, Object primaryKey, LockModeType lockModeType, Map<String,Object> properties)` Find by primary key and lock, using the specified properties.
`<T> T`	`find(Class<T> entityClass, Object primaryKey, Map<String,Object> properties)` Find by primary key, using the specified properties.
`void`	`flush()` Synchronize the persistence context to the underlying database.
`CriteriaBuilder`	`getCriteriaBuilder()` Return an instance of `CriteriaBuilder` for the creation of `CriteriaQuery` objects.
`Object`	`getDelegate()` returns the underlying session
`EntityManagerFactoryImpl`	`getEntityManagerFactory()` Return the entity manager factory for the entity manager.
`HibernateEntityManagerFactory`	`getFactory()` Get access to the Hibernate extended EMF contract.
`FlushModeType`	`getFlushMode()` Hibernate can be set in various flush modes that are unknown to JPA 2.0.
`LockModeType`	`getLockMode(Object entity)` Get the current lock mode for the entity instance.
`LockOptions`	`getLockRequest(LockModeType lockModeType, Map<String,Object> properties)` Convert from JPA 2 `LockModeType` & properties into `LockOptions`
`Metamodel`	`getMetamodel()` Return an instance of `Metamodel` interface for access to the metamodel of the persistence unit.
`Map<String,Object>`	`getProperties()` Get the properties and hints and associated values that are in effect for the entity manager.
`protected abstract Session`	`getRawSession()` Return a Session (even if the entity manager is closed).
`<T> T`	`getReference(Class<T> entityClass, Object primaryKey)` Get an instance, whose state may be lazily fetched.
`abstract Session`	`getSession()` return a Session
`EntityTransaction`	`getTransaction()` Return the resource-level `EntityTransaction` object.
`PersistenceUnitTransactionType`	`getTransactionType()`
`void`	`handlePersistenceException(PersistenceException e)` Handles marking for rollback and other such operations that need to occur depending on the type of exception being handled.
`boolean`	`isTransactionInProgress()` Provides access to whether a transaction is currently in progress.
`void`	`joinTransaction()` Indicate to the entity manager that a JTA transaction is active.
`void`	`lock(Object entity, LockModeType lockMode)` Lock an entity instance that is contained in the persistence context with the specified lock mode type.
`void`	`lock(Object entity, LockModeType lockModeType, Map<String,Object> properties)` Lock an entity instance that is contained in the persistence context with the specified lock mode type and with specified properties.
`protected void`	`markAsRollback()`
`<A> A`	`merge(A entity)` Merge the state of the given entity into the current persistence context.
`void`	`persist(Object entity)` Make an instance managed and persistent.
`protected void`	`postInit()`
`void`	`refresh(Object entity)` Refresh the state of the instance from the database, overwriting changes made to the entity, if any.
`void`	`refresh(Object entity, LockModeType lockModeType)` Refresh the state of the instance from the database, overwriting changes made to the entity, if any, and lock it with respect to given lock mode type.
`void`	`refresh(Object entity, LockModeType lockModeType, Map<String,Object> properties)` Refresh the state of the instance from the database, overwriting changes made to the entity, if any, and lock it with respect to given lock mode type and with specified properties.
`void`	`refresh(Object entity, Map<String,Object> properties)` Refresh the state of the instance from the database, using the specified properties, and overwriting changes made to the entity, if any.
`void`	`remove(Object entity)` Remove the entity instance.
`void`	`setFlushMode(FlushModeType flushModeType)` Set the flush mode that applies to all objects contained in the persistence context.
`void`	`setProperty(String s, Object o)` Set an entity manager property or hint.
`void`	`throwPersistenceException(HibernateException e)` Delegates to `HibernateEntityManagerImplementor.convert(org.hibernate.HibernateException, org.hibernate.LockOptions)` and then throws the given exception.
`void`	`throwPersistenceException(PersistenceException e)` Delegates to `HibernateEntityManagerImplementor.handlePersistenceException(javax.persistence.PersistenceException)` and then throws the given exception.
`<T> T`	`unwrap(Class<T> clazz)` Return an object of the specified type to allow access to the provider-specific API.
`PersistenceException`	`wrapLockException(HibernateException e, LockOptions lockOptions)`
`PersistenceException`	`wrapStaleStateException(StaleStateException e)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface javax.persistence.EntityManager
close, isOpen

- Field Detail
  - tx
```
protected transient TransactionImpl tx
```
  - persistenceContextType
```
protected PersistenceContextType persistenceContextType
```
- Constructor Detail
  - AbstractEntityManagerImpl
```
protected AbstractEntityManagerImpl(EntityManagerFactoryImpl entityManagerFactory,
                         PersistenceContextType type,
                         PersistenceUnitTransactionType transactionType,
                         Map properties)
```
- Method Detail
  - getTransactionType
```
public PersistenceUnitTransactionType getTransactionType()
```
  - postInit
```
protected void postInit()
```
  - createQuery
```
public Query createQuery(String jpaqlString)
```
    Description copied from interface: EntityManager
    
    Create an instance of Query for executing a Java Persistence query language statement.
    
    Specified by:
    
    createQuery in interface EntityManager
    
    Parameters:
    jpaqlString - a Java Persistence query string
    
    Returns:
    the new query instance
  - createQuery
```
public <T> TypedQuery<T> createQuery(String jpaqlString,
                            Class<T> resultClass)
```
    Description copied from interface: EntityManager
    
    Create an instance of TypedQuery for executing a Java Persistence query language statement. The select list of the query must contain only a single item, which must be assignable to the type specified by the resultClass argument.
    
    Specified by:
    
    createQuery in interface EntityManager
    
    Parameters:
    jpaqlString - a Java Persistence query string
    resultClass - the type of the query result
    
    Returns:
    the new query instance
  - createQuery
```
public <T> TypedQuery<T> createQuery(String jpaqlString,
                            Class<T> resultClass,
                            Selection selection,
                            HibernateEntityManagerImplementor.Options options)
```
    Description copied from interface: HibernateEntityManagerImplementor
    
    Used during "compiling" a JPA criteria query.
    
    Specified by:
    
    createQuery in interface HibernateEntityManagerImplementor
    
    Type Parameters:
    T - The query type
    Parameters:
    jpaqlString - The criteria query rendered as a JPA QL string
    resultClass - The result type (the type expected in the result list)
    selection - The selection(s)
    options - The options to use to build the query.
    
    Returns:
    The typed query
  - createQuery
```
public <T> TypedQuery<T> createQuery(CriteriaQuery<T> criteriaQuery)
```
    Description copied from interface: EntityManager
    
    Create an instance of TypedQuery for executing a criteria query.
    
    Specified by:
    
    createQuery in interface EntityManager
    
    Parameters:
    criteriaQuery - a criteria query object
    
    Returns:
    the new query instance
  - createNamedQuery
```
public Query createNamedQuery(String name)
```
    Description copied from interface: EntityManager
    
    Create an instance of Query for executing a named query (in the Java Persistence query language or in native SQL).
    
    Specified by:
    
    createNamedQuery in interface EntityManager
    
    Parameters:
    name - the name of a query defined in metadata
    
    Returns:
    the new query instance
  - createNamedQuery
```
public <T> TypedQuery<T> createNamedQuery(String name,
                                 Class<T> resultClass)
```
    Description copied from interface: EntityManager
    
    Create an instance of TypedQuery for executing a Java Persistence query language named query. The select list of the query must contain only a single item, which must be assignable to the type specified by the resultClass argument.
    
    Specified by:
    
    createNamedQuery in interface EntityManager
    
    Parameters:
    name - the name of a query defined in metadata
    resultClass - the type of the query result
    
    Returns:
    the new query instance
  - createNativeQuery
```
public Query createNativeQuery(String sqlString)
```
    Description copied from interface: EntityManager
    
    Create an instance of Query for executing a native SQL statement, e.g., for update or delete.
    
    Specified by:
    
    createNativeQuery in interface EntityManager
    
    Parameters:
    sqlString - a native SQL query string
    
    Returns:
    the new query instance
  - createNativeQuery
```
public Query createNativeQuery(String sqlString,
                      Class resultClass)
```
    Description copied from interface: EntityManager
    
    Create an instance of Query for executing a native SQL query.
    
    Specified by:
    
    createNativeQuery in interface EntityManager
    
    Parameters:
    sqlString - a native SQL query string
    resultClass - the class of the resulting instance(s)
    
    Returns:
    the new query instance
  - createNativeQuery
```
public Query createNativeQuery(String sqlString,
                      String resultSetMapping)
```
    Description copied from interface: EntityManager
    
    Create an instance of Query for executing a native SQL query.
    
    Specified by:
    
    createNativeQuery in interface EntityManager
    
    Parameters:
    sqlString - a native SQL query string
    resultSetMapping - the name of the result set mapping
    
    Returns:
    the new query instance
  - getReference
```
public <T> T getReference(Class<T> entityClass,
                 Object primaryKey)
```
    Description copied from interface: EntityManager
    
    Get an instance, whose state may be lazily fetched. If the requested instance does not exist in the database, the EntityNotFoundException is thrown when the instance state is first accessed. (The persistence provider runtime is permitted to throw the EntityNotFoundException when getReference is called.) The application should not expect that the instance state will be available upon detachment, unless it was accessed by the application while the entity manager was open.
    
    Specified by:
    
    getReference in interface EntityManager
    
    Parameters:
    entityClass - entity class
    primaryKey - primary key
    
    Returns:
    the found entity instance
  - find
```
public <A> A find(Class<A> entityClass,
         Object primaryKey)
```
    Description copied from interface: EntityManager
    
    Find by primary key. Search for an entity of the specified class and primary key. If the entity instance is contained in the persistence context, it is returned from there.
    
    Specified by:
    
    find in interface EntityManager
    
    Parameters:
    entityClass - entity class
    primaryKey - primary key
    
    Returns:
    the found entity instance or null if the entity does not exist
  - find
```
public <T> T find(Class<T> entityClass,
         Object primaryKey,
         Map<String,Object> properties)
```
    Description copied from interface: EntityManager
    
    Find by primary key, using the specified properties. Search for an entity of the specified class and primary key. If the entity instance is contained in the persistence context, it is returned from there. If a vendor-specific property or hint is not recognized, it is silently ignored.
    
    Specified by:
    
    find in interface EntityManager
    
    Parameters:
    entityClass - entity class
    primaryKey - primary key
    properties - standard and vendor-specific properties and hints
    
    Returns:
    the found entity instance or null if the entity does not exist
  - find
```
public <A> A find(Class<A> entityClass,
         Object primaryKey,
         LockModeType lockModeType)
```
    Description copied from interface: EntityManager
    Find by primary key and lock. Search for an entity of the specified class and primary key and lock it with respect to the specified lock type. If the entity instance is contained in the persistence context, it is returned from there, and the effect of this method is the same as if the lock method had been called on the entity.
    If the entity is found within the persistence context and the lock mode type is pessimistic and the entity has a version attribute, the persistence provider must perform optimistic version checks when obtaining the database lock. If these checks fail, the OptimisticLockException will be thrown.
    If the lock mode type is pessimistic and the entity instance is found but cannot be locked:
    - the PessimisticLockException will be thrown if the database locking failure causes transaction-level rollback
    - the LockTimeoutException will be thrown if the database locking failure causes only statement-level rollback
    Specified by:
    
    find in interface EntityManager
    
    Parameters:
    entityClass - entity class
    primaryKey - primary key
    lockModeType - lock mode
    
    Returns:
    the found entity instance or null if the entity does not exist
  - find
```
public <A> A find(Class<A> entityClass,
         Object primaryKey,
         LockModeType lockModeType,
         Map<String,Object> properties)
```
    Description copied from interface: EntityManager
    Find by primary key and lock, using the specified properties. Search for an entity of the specified class and primary key and lock it with respect to the specified lock type. If the entity instance is contained in the persistence context, it is returned from there.
    If the entity is found within the persistence context and the lock mode type is pessimistic and the entity has a version attribute, the persistence provider must perform optimistic version checks when obtaining the database lock. If these checks fail, the OptimisticLockException will be thrown.
    If the lock mode type is pessimistic and the entity instance is found but cannot be locked:
    - the PessimisticLockException will be thrown if the database locking failure causes transaction-level rollback
    - the LockTimeoutException will be thrown if the database locking failure causes only statement-level rollback
    If a vendor-specific property or hint is not recognized, it is silently ignored.
    Portable applications should not rely on the standard timeout hint. Depending on the database in use and the locking mechanisms used by the provider, the hint may or may not be observed.
    Specified by:
    
    find in interface EntityManager
    
    Parameters:
    entityClass - entity class
    primaryKey - primary key
    lockModeType - lock mode
    properties - standard and vendor-specific properties and hints
    
    Returns:
    the found entity instance or null if the entity does not exist
  - determineAppropriateLocalCacheMode
```
public CacheMode determineAppropriateLocalCacheMode(Map<String,Object> localProperties)
```
  - persist
```
public void persist(Object entity)
```
    Description copied from interface: EntityManager
    
    Make an instance managed and persistent.
    
    Specified by:
    
    persist in interface EntityManager
    
    Parameters:
    entity - entity instance
  - merge
```
public <A> A merge(A entity)
```
    Description copied from interface: EntityManager
    
    Merge the state of the given entity into the current persistence context.
    
    Specified by:
    
    merge in interface EntityManager
    
    Parameters:
    entity - entity instance
    
    Returns:
    the managed instance that the state was merged to
  - remove
```
public void remove(Object entity)
```
    Description copied from interface: EntityManager
    
    Remove the entity instance.
    
    Specified by:
    
    remove in interface EntityManager
    
    Parameters:
    entity - entity instance
  - refresh
```
public void refresh(Object entity)
```
    Description copied from interface: EntityManager
    
    Refresh the state of the instance from the database, overwriting changes made to the entity, if any.
    
    Specified by:
    
    refresh in interface EntityManager
    
    Parameters:
    entity - entity instance
  - refresh
```
public void refresh(Object entity,
           Map<String,Object> properties)
```
    Description copied from interface: EntityManager
    
    Refresh the state of the instance from the database, using the specified properties, and overwriting changes made to the entity, if any.
    If a vendor-specific property or hint is not recognized, it is silently ignored.
    
    Specified by:
    
    refresh in interface EntityManager
    
    Parameters:
    entity - entity instance
    properties - standard and vendor-specific properties and hints
  - refresh
```
public void refresh(Object entity,
           LockModeType lockModeType)
```
    Description copied from interface: EntityManager
    Refresh the state of the instance from the database, overwriting changes made to the entity, if any, and lock it with respect to given lock mode type.
    If the lock mode type is pessimistic and the entity instance is found but cannot be locked:
    - the PessimisticLockException will be thrown if the database locking failure causes transaction-level rollback
    - the LockTimeoutException will be thrown if the database locking failure causes only statement-level rollback.
    Specified by:
    
    refresh in interface EntityManager
    
    Parameters:
    entity - entity instance
    lockModeType - lock mode
  - refresh
```
public void refresh(Object entity,
           LockModeType lockModeType,
           Map<String,Object> properties)
```
    Description copied from interface: EntityManager
    Refresh the state of the instance from the database, overwriting changes made to the entity, if any, and lock it with respect to given lock mode type and with specified properties.
    If the lock mode type is pessimistic and the entity instance is found but cannot be locked:
    - the PessimisticLockException will be thrown if the database locking failure causes transaction-level rollback
    - the LockTimeoutException will be thrown if the database locking failure causes only statement-level rollback
    If a vendor-specific property or hint is not recognized, it is silently ignored.
    Portable applications should not rely on the standard timeout hint. Depending on the database in use and the locking mechanisms used by the provider, the hint may or may not be observed.
    Specified by:
    
    refresh in interface EntityManager
    
    Parameters:
    entity - entity instance
    lockModeType - lock mode
    properties - standard and vendor-specific properties and hints
  - contains
```
public boolean contains(Object entity)
```
    Description copied from interface: EntityManager
    
    Check if the instance is a managed entity instance belonging to the current persistence context.
    
    Specified by:
    
    contains in interface EntityManager
    
    Parameters:
    entity - entity instance
    
    Returns:
    boolean indicating if entity is in persistence context
  - getLockMode
```
public LockModeType getLockMode(Object entity)
```
    Description copied from interface: EntityManager
    
    Get the current lock mode for the entity instance.
    
    Specified by:
    
    getLockMode in interface EntityManager
    
    Parameters:
    entity - entity instance
    
    Returns:
    lock mode
  - setProperty
```
public void setProperty(String s,
               Object o)
```
    Description copied from interface: EntityManager
    
    Set an entity manager property or hint. If a vendor-specific property or hint is not recognized, it is silently ignored.
    
    Specified by:
    
    setProperty in interface EntityManager
    
    Parameters:
    s - name of property or hint
    o - value for property or hint
  - getProperties
```
public Map<String,Object> getProperties()
```
    Description copied from interface: EntityManager
    
    Get the properties and hints and associated values that are in effect for the entity manager. Changing the contents of the map does not change the configuration in effect.
    
    Specified by:
    
    getProperties in interface EntityManager
    
    Returns:
    map of properties and hints in effect for entity manager
  - flush
```
public void flush()
```
    Description copied from interface: EntityManager
    
    Synchronize the persistence context to the underlying database.
    
    Specified by:
    
    flush in interface EntityManager
  - getSession
```
public abstract Session getSession()
```
    return a Session
    
    Specified by:
    
    getSession in interface HibernateEntityManager
    
    Returns:
    The session
    
    Throws:
    
    IllegalStateException - if the entity manager is closed
  - getRawSession
```
protected abstract Session getRawSession()
```
    Return a Session (even if the entity manager is closed).
    
    Returns:
    A session.
  - getTransaction
```
public EntityTransaction getTransaction()
```
    Description copied from interface: EntityManager
    
    Return the resource-level EntityTransaction object. The EntityTransaction instance may be used serially to begin and commit multiple transactions.
    
    Specified by:
    
    getTransaction in interface EntityManager
    
    Returns:
    EntityTransaction instance
  - getEntityManagerFactory
```
public EntityManagerFactoryImpl getEntityManagerFactory()
```
    Return the entity manager factory for the entity manager.
    
    Specified by:
    
    getEntityManagerFactory in interface EntityManager
    
    Returns:
    EntityManagerFactory instance
  - getFactory
```
public HibernateEntityManagerFactory getFactory()
```
    Get access to the Hibernate extended EMF contract.
    
    Specified by:
    
    getFactory in interface HibernateEntityManagerImplementor
    
    Returns:
    The Hibernate EMF contract for this EM.
  - getCriteriaBuilder
```
public CriteriaBuilder getCriteriaBuilder()
```
    Return an instance of CriteriaBuilder for the creation of CriteriaQuery objects.
    
    Specified by:
    
    getCriteriaBuilder in interface EntityManager
    
    Returns:
    CriteriaBuilder instance
  - getMetamodel
```
public Metamodel getMetamodel()
```
    Return an instance of Metamodel interface for access to the metamodel of the persistence unit.
    
    Specified by:
    
    getMetamodel in interface EntityManager
    
    Returns:
    Metamodel instance
  - setFlushMode
```
public void setFlushMode(FlushModeType flushModeType)
```
    Description copied from interface: EntityManager
    
    Set the flush mode that applies to all objects contained in the persistence context.
    
    Specified by:
    
    setFlushMode in interface EntityManager
    
    Parameters:
    flushModeType - flush mode
  - clear
```
public void clear()
```
    Description copied from interface: EntityManager
    
    Clear the persistence context, causing all managed entities to become detached. Changes made to entities that have not been flushed to the database will not be persisted.
    
    Specified by:
    
    clear in interface EntityManager
  - detach
```
public void detach(Object entity)
```
    Description copied from interface: EntityManager
    
    Remove the given entity from the persistence context, causing a managed entity to become detached. Unflushed changes made to the entity if any (including removal of the entity), will not be synchronized to the database. Entities which previously referenced the detached entity will continue to reference it.
    
    Specified by:
    
    detach in interface EntityManager
    
    Parameters:
    entity - entity instance
  - getFlushMode
```
public FlushModeType getFlushMode()
```
    Hibernate can be set in various flush modes that are unknown to JPA 2.0. This method can then return null. If it returns null, do em.unwrap(Session.class).getFlushMode() to get the Hibernate flush mode
    
    Specified by:
    
    getFlushMode in interface EntityManager
    
    Returns:
    flushMode
  - lock
```
public void lock(Object entity,
        LockModeType lockMode)
```
    Description copied from interface: EntityManager
    Lock an entity instance that is contained in the persistence context with the specified lock mode type.
    If a pessimistic lock mode type is specified and the entity contains a version attribute, the persistence provider must also perform optimistic version checks when obtaining the database lock. If these checks fail, the OptimisticLockException will be thrown.
    If the lock mode type is pessimistic and the entity instance is found but cannot be locked:
    - the PessimisticLockException will be thrown if the database locking failure causes transaction-level rollback
    - the LockTimeoutException will be thrown if the database locking failure causes only statement-level rollback
    Specified by:
    
    lock in interface EntityManager
    
    Parameters:
    entity - entity instance
    lockMode - lock mode
  - lock
```
public void lock(Object entity,
        LockModeType lockModeType,
        Map<String,Object> properties)
```
    Description copied from interface: EntityManager
    Lock an entity instance that is contained in the persistence context with the specified lock mode type and with specified properties.
    If a pessimistic lock mode type is specified and the entity contains a version attribute, the persistence provider must also perform optimistic version checks when obtaining the database lock. If these checks fail, the OptimisticLockException will be thrown.
    If the lock mode type is pessimistic and the entity instance is found but cannot be locked:
    - the PessimisticLockException will be thrown if the database locking failure causes transaction-level rollback
    - the LockTimeoutException will be thrown if the database locking failure causes only statement-level rollback
    If a vendor-specific property or hint is not recognized, it is silently ignored.
    Portable applications should not rely on the standard timeout hint. Depending on the database in use and the locking mechanisms used by the provider, the hint may or may not be observed.
    Specified by:
    
    lock in interface EntityManager
    
    Parameters:
    entity - entity instance
    lockModeType - lock mode
    properties - standard and vendor-specific properties and hints
  - getLockRequest
```
public LockOptions getLockRequest(LockModeType lockModeType,
                         Map<String,Object> properties)
```
    Description copied from interface: HibernateEntityManagerImplementor
    
    Convert from JPA 2 LockModeType & properties into LockOptions
    
    Specified by:
    
    getLockRequest in interface HibernateEntityManagerImplementor
    
    Parameters:
    lockModeType - is the requested lock type
    properties - are the lock properties
    
    Returns:
    the LockOptions
  - isTransactionInProgress
```
public boolean isTransactionInProgress()
```
    Description copied from interface: HibernateEntityManagerImplementor
    
    Provides access to whether a transaction is currently in progress.
    
    Specified by:
    
    isTransactionInProgress in interface HibernateEntityManagerImplementor
    
    Returns:
    True if a transaction is considered currently in progress; false otherwise.
  - markAsRollback
```
protected void markAsRollback()
```
  - joinTransaction
```
public void joinTransaction()
```
    Description copied from interface: EntityManager
    
    Indicate to the entity manager that a JTA transaction is active. This method should be called on a JTA application managed entity manager that was created outside the scope of the active transaction to associate it with the current JTA transaction.
    
    Specified by:
    
    joinTransaction in interface EntityManager
  - unwrap
```
public <T> T unwrap(Class<T> clazz)
```
    Description copied from interface: EntityManager
    
    Return an object of the specified type to allow access to the provider-specific API. If the provider's EntityManager implementation does not support the specified class, the PersistenceException is thrown.
    
    Specified by:
    
    unwrap in interface EntityManager
    
    Parameters:
    clazz - the class of the object to be returned. This is normally either the underlying EntityManager implementation class or an interface that it implements.
    
    Returns:
    an instance of the specified class
  - getDelegate
```
public Object getDelegate()
```
    returns the underlying session
    
    Specified by:
    
    getDelegate in interface EntityManager
    
    Returns:
    underlying provider object for EntityManager
  - handlePersistenceException
```
public void handlePersistenceException(PersistenceException e)
```
    Handles marking for rollback and other such operations that need to occur depending on the type of exception being handled.
    
    Specified by:
    
    handlePersistenceException in interface HibernateEntityManagerImplementor
    
    Parameters:
    e - The exception being handled.
  - throwPersistenceException
```
public void throwPersistenceException(PersistenceException e)
```
    Delegates to HibernateEntityManagerImplementor.handlePersistenceException(javax.persistence.PersistenceException) and then throws the given exception.
    
    Specified by:
    
    throwPersistenceException in interface HibernateEntityManagerImplementor
    
    Parameters:
    e - The exception being handled and finally thrown.
  - convert
```
public RuntimeException 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.
    Any appropriate/needed calls to HibernateEntityManagerImplementor.handlePersistenceException(javax.persistence.PersistenceException) are also made.
    
    Specified by:
    
    convert in interface HibernateEntityManagerImplementor
    
    Parameters:
    e - The Hibernate excepton.
    
    Returns:
    The JPA-specified exception
  - convert
```
public RuntimeException convert(RuntimeException e)
```
  - convert
```
public RuntimeException 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.
    Any appropriate/needed calls to HibernateEntityManagerImplementor.handlePersistenceException(javax.persistence.PersistenceException) are also made.
    
    Specified by:
    
    convert in interface HibernateEntityManagerImplementor
    
    Parameters:
    e - The Hibernate excepton.
    lockOptions - The lock options in effect at the time of exception (can be null)
    
    Returns:
    The JPA-specified exception
  - throwPersistenceException
```
public void throwPersistenceException(HibernateException e)
```
    Delegates to HibernateEntityManagerImplementor.convert(org.hibernate.HibernateException, org.hibernate.LockOptions) and then throws the given exception.
    
    Specified by:
    
    throwPersistenceException in interface HibernateEntityManagerImplementor
    
    Parameters:
    e - The exception being handled and finally thrown.
  - wrapStaleStateException
```
public PersistenceException wrapStaleStateException(StaleStateException e)
```
    Specified by:
    
    wrapStaleStateException in interface HibernateEntityManagerImplementor
  - wrapLockException
```
public PersistenceException wrapLockException(HibernateException e,
                                     LockOptions lockOptions)
```

Class AbstractEntityManagerImpl

Nested Class Summary

Nested classes/interfaces inherited from interface org.hibernate.ejb.HibernateEntityManagerImplementor

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface javax.persistence.EntityManager

Field Detail

tx

persistenceContextType

Constructor Detail

AbstractEntityManagerImpl

Method Detail

getTransactionType

postInit

createQuery

createQuery

createQuery

createQuery

createNamedQuery

createNamedQuery

createNativeQuery

createNativeQuery

createNativeQuery

getReference

find

find

find

find

determineAppropriateLocalCacheMode

persist

merge

remove

refresh

refresh

refresh

refresh

contains

getLockMode

setProperty

getProperties

flush

getSession

getRawSession

getTransaction

getEntityManagerFactory

getFactory

getCriteriaBuilder

getMetamodel

setFlushMode

clear

detach

getFlushMode

lock

lock

getLockRequest

isTransactionInProgress

markAsRollback

joinTransaction

unwrap

getDelegate

handlePersistenceException

throwPersistenceException

convert

convert

convert

throwPersistenceException

wrapStaleStateException

wrapLockException