JtaEntityManager

java.lang.Object
- org.apache.openejb.persistence.JtaEntityManager

All Implemented Interfaces:

java.io.Serializable, EntityManager
```
public class JtaEntityManager
extends java.lang.Object
implements EntityManager, java.io.Serializable
```
The JtaEntityManager is a wrapper around an entity manager that automatically creates and closes entity managers for each transaction in which it is accessed. This implementation supports both transaction and extended scoped JTA entity managers.
It is important that extended scoped entity managers add entity managers to the JtaEntityManagerRegistry when the component is entered and remove them when exited. If this registration is not preformed, an IllegalStateException will be thrown when entity manger is used. It is important that a component adds extended scoped entity managers to the JtaEntityManagerRegistry when the component is entered and removes them when exited. If this registration is not preformed, an IllegalStateException will be thrown when entity manger is accessed.

See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class JtaEntityManager.Timer

Nested Classes
Modifier and Type	Class and Description
`static class`	`JtaEntityManager.Timer`

Constructor Summary

Constructors
Constructor and Description
`JtaEntityManager(JtaEntityManagerRegistry registry, EntityManagerFactory entityManagerFactory, java.util.Map properties, java.lang.String unitName, java.lang.String synchronizationType)`
`JtaEntityManager(java.lang.String unitName, JtaEntityManagerRegistry registry, EntityManagerFactory entityManagerFactory, java.util.Map properties, boolean extended, java.lang.String synchronizationType)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`clear()` Clear the persistence context, causing all managed entities to become detached.
`void`	`close()` close throws an IllegalStateException if the em is container managed otherwise (emf.newEM()) it is delegated to the user
`boolean`	`contains(java.lang.Object entity)` Check if the instance is a managed entity instance belonging to the current persistence context.
`<T> EntityGraph<T>`	`createEntityGraph(java.lang.Class<T> rootType)` Return a mutable EntityGraph that can be used to dynamically create an EntityGraph.
`EntityGraph<?>`	`createEntityGraph(java.lang.String graphName)` Return a mutable copy of the named EntityGraph.
`Query`	`createNamedQuery(java.lang.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(java.lang.String name, java.lang.Class<T> resultClass)` Create an instance of `TypedQuery` for executing a Java Persistence query language named query.
`StoredProcedureQuery`	`createNamedStoredProcedureQuery(java.lang.String name)` Create an instance of `StoredProcedureQuery` for executing a stored procedure in the database.
`Query`	`createNativeQuery(java.lang.String sqlString)` Create an instance of `Query` for executing a native SQL statement, e.g., for update or delete.
`Query`	`createNativeQuery(java.lang.String sqlString, java.lang.Class resultClass)` Create an instance of `Query` for executing a native SQL query.
`Query`	`createNativeQuery(java.lang.String sqlString, java.lang.String resultSetMapping)` Create an instance of `Query` for executing a native SQL query.
`Query`	`createQuery(CriteriaDelete deleteQuery)` Create an instance of `Query` for executing a criteria delete query.
`<T> TypedQuery<T>`	`createQuery(CriteriaQuery<T> criteriaQuery)` Create an instance of `TypedQuery` for executing a criteria query.
`Query`	`createQuery(CriteriaUpdate updateQuery)` Create an instance of `Query` for executing a criteria update query.
`Query`	`createQuery(java.lang.String qlString)` Create an instance of `Query` for executing a Java Persistence query language statement.
`<T> TypedQuery<T>`	`createQuery(java.lang.String qlString, java.lang.Class<T> resultClass)` Create an instance of `TypedQuery` for executing a Java Persistence query language statement.
`StoredProcedureQuery`	`createStoredProcedureQuery(java.lang.String procedureName)` Create an instance of `StoredProcedureQuery` for executing a stored procedure in the database.
`StoredProcedureQuery`	`createStoredProcedureQuery(java.lang.String procedureName, java.lang.Class... resultClasses)` Create an instance of `StoredProcedureQuery` for executing a stored procedure in the database.
`StoredProcedureQuery`	`createStoredProcedureQuery(java.lang.String procedureName, java.lang.String... resultSetMappings)` Create an instance of `StoredProcedureQuery` for executing a stored procedure in the database.
`void`	`detach(java.lang.Object entity)` Remove the given entity from the persistence context, causing a managed entity to become detached.
`<T> T`	`find(java.lang.Class<T> entityClass, java.lang.Object primaryKey)` Find by primary key.
`<T> T`	`find(java.lang.Class<T> entityClass, java.lang.Object primaryKey, LockModeType lockMode)` Find by primary key and lock.
`<T> T`	`find(java.lang.Class<T> entityClass, java.lang.Object primaryKey, LockModeType lockMode, java.util.Map<java.lang.String,java.lang.Object> properties)` Find by primary key and lock, using the specified properties.
`<T> T`	`find(java.lang.Class<T> entityClass, java.lang.Object primaryKey, java.util.Map<java.lang.String,java.lang.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.
`EntityManager`	`getDelegate()` Return the underlying provider object for the `EntityManager`, if available.
`EntityGraph<?>`	`getEntityGraph(java.lang.String graphName)` Return a named EntityGraph.
`<T> java.util.List<EntityGraph<? super T>>`	`getEntityGraphs(java.lang.Class<T> entityClass)` Return all named EntityGraphs that have been defined for the provided class type.
`EntityManagerFactory`	`getEntityManagerFactory()` Return the entity manager factory for the entity manager.
`FlushModeType`	`getFlushMode()` Get the flush mode that applies to all objects contained in the persistence context.
`LockModeType`	`getLockMode(java.lang.Object entity)` Get the current lock mode for the entity instance.
`Metamodel`	`getMetamodel()` Return an instance of `Metamodel` interface for access to the metamodel of the persistence unit.
`java.util.Map<java.lang.String,java.lang.Object>`	`getProperties()` Get the properties and hints and associated values that are in effect for the entity manager.
`<T> T`	`getReference(java.lang.Class<T> entityClass, java.lang.Object primaryKey)` Get an instance, whose state may be lazily fetched.
`EntityTransaction`	`getTransaction()` Return the resource-level `EntityTransaction` object.
`boolean`	`isJoinedToTransaction()` Determine whether the entity manager is joined to the current transaction.
`static boolean`	`isJPA21(EntityManagerFactory entityManagerFactory)`
`boolean`	`isOpen()` Determine whether the entity manager is open.
`void`	`joinTransaction()` Indicate to the entity manager that a JTA transaction is active and join the persistence context to it.
`void`	`lock(java.lang.Object entity, LockModeType lockMode)` Lock an entity instance that is contained in the persistence context with the specified lock mode type.
`void`	`lock(java.lang.Object entity, LockModeType lockMode, java.util.Map<java.lang.String,java.lang.Object> properties)` Lock an entity instance that is contained in the persistence context with the specified lock mode type and with specified properties.
`<T> T`	`merge(T entity)` Merge the state of the given entity into the current persistence context.
`void`	`persist(java.lang.Object entity)` Make an instance managed and persistent.
`void`	`refresh(java.lang.Object entity)` Refresh the state of the instance from the database, overwriting changes made to the entity, if any.
`void`	`refresh(java.lang.Object entity, LockModeType lockMode)` 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(java.lang.Object entity, LockModeType lockMode, java.util.Map<java.lang.String,java.lang.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(java.lang.Object entity, java.util.Map<java.lang.String,java.lang.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(java.lang.Object entity)` Remove the entity instance.
`void`	`setFlushMode(FlushModeType flushMode)` Set the flush mode that applies to all objects contained in the persistence context.
`void`	`setProperty(java.lang.String name, java.lang.Object value)` Set an entity manager property or hint.
`<T> T`	`unwrap(java.lang.Class<T> cls)` Return an object of the specified type to allow access to the provider-specific API.
`protected java.lang.Object`	`writeReplace()`

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

- Constructor Detail
  - JtaEntityManager
```
public JtaEntityManager(JtaEntityManagerRegistry registry,
                        EntityManagerFactory entityManagerFactory,
                        java.util.Map properties,
                        java.lang.String unitName,
                        java.lang.String synchronizationType)
```
  - JtaEntityManager
```
public JtaEntityManager(java.lang.String unitName,
                        JtaEntityManagerRegistry registry,
                        EntityManagerFactory entityManagerFactory,
                        java.util.Map properties,
                        boolean extended,
                        java.lang.String synchronizationType)
```
- Method Detail
  - isJPA21
```
public static boolean isJPA21(EntityManagerFactory entityManagerFactory)
```
  - getDelegate
```
public EntityManager getDelegate()
```
    Description copied from interface: EntityManager
    
    Return the underlying provider object for the EntityManager, if available. The result of this method is implementation specific.
    The unwrap method is to be preferred for new applications.
    
    Specified by:
    
    getDelegate in interface EntityManager
    
    Returns:
    
    underlying provider object for EntityManager
  - persist
```
public void persist(java.lang.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 <T> T merge(T 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(java.lang.Object entity)
```
    Description copied from interface: EntityManager
    
    Remove the entity instance.
    
    Specified by:
    
    remove in interface EntityManager
    
    Parameters:
    
    entity - entity instance
  - find
```
public <T> T find(java.lang.Class<T> entityClass,
                  java.lang.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
  - getReference
```
public <T> T getReference(java.lang.Class<T> entityClass,
                          java.lang.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
  - flush
```
public void flush()
```
    Description copied from interface: EntityManager
    
    Synchronize the persistence context to the underlying database.
    
    Specified by:
    
    flush in interface EntityManager
  - setFlushMode
```
public void setFlushMode(FlushModeType flushMode)
```
    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:
    
    flushMode - flush mode
  - getFlushMode
```
public FlushModeType getFlushMode()
```
    Description copied from interface: EntityManager
    
    Get the flush mode that applies to all objects contained in the persistence context.
    
    Specified by:
    
    getFlushMode in interface EntityManager
    
    Returns:
    
    flushMode
  - lock
```
public void lock(java.lang.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
  - refresh
```
public void refresh(java.lang.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
  - 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
  - contains
```
public boolean contains(java.lang.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
  - createQuery
```
public Query createQuery(java.lang.String qlString)
```
    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:
    
    qlString - a Java Persistence query string
    
    Returns:
    
    the new query instance
  - createNamedQuery
```
public Query createNamedQuery(java.lang.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
  - createNativeQuery
```
public Query createNativeQuery(java.lang.String sqlString)
```
    Description copied from interface: EntityManager
    
    Create an instance of Query for executing a native SQL statement, e.g., for update or delete. If the query is not an update or delete query, query execution will result in each row of the SQL result being returned as a result of type Object[] (or a result of type Object if there is only one column in the select list.) Column values are returned in the order of their appearance in the select list and default JDBC type mappings are applied.
    
    Specified by:
    
    createNativeQuery in interface EntityManager
    
    Parameters:
    
    sqlString - a native SQL query string
    
    Returns:
    
    the new query instance
  - createNativeQuery
```
public Query createNativeQuery(java.lang.String sqlString,
                               java.lang.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(java.lang.String sqlString,
                               java.lang.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
  - joinTransaction
```
public void joinTransaction()
```
    Description copied from interface: EntityManager
    
    Indicate to the entity manager that a JTA transaction is active and join the persistence context to it.
    This method should be called on a JTA application managed entity manager that was created outside the scope of the active transaction or on an entity manager of type SynchronizationType.UNSYNCHRONIZED to associate it with the current JTA transaction.
    
    Specified by:
    
    joinTransaction in interface EntityManager
  - close
```
public void close()
```
    close throws an IllegalStateException if the em is container managed otherwise (emf.newEM()) it is delegated to the user
    
    Specified by:
    
    close in interface EntityManager
  - isOpen
```
public boolean isOpen()
```
    Description copied from interface: EntityManager
    
    Determine whether the entity manager is open.
    
    Specified by:
    
    isOpen in interface EntityManager
    
    Returns:
    
    true until the entity manager has been closed
  - 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
  - createNamedQuery
```
public <T> TypedQuery<T> createNamedQuery(java.lang.String name,
                                          java.lang.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
  - 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
  - createQuery
```
public <T> TypedQuery<T> createQuery(java.lang.String qlString,
                                     java.lang.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:
    
    qlString - a Java Persistence query string
    
    resultClass - the type of the query result
    
    Returns:
    
    the new query instance
  - detach
```
public void detach(java.lang.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
  - find
```
public <T> T find(java.lang.Class<T> entityClass,
                  java.lang.Object primaryKey,
                  java.util.Map<java.lang.String,java.lang.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 <T> T find(java.lang.Class<T> entityClass,
                  java.lang.Object primaryKey,
                  LockModeType lockMode)
```
    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
    
    lockMode - lock mode
    
    Returns:
    
    the found entity instance or null if the entity does not exist
  - find
```
public <T> T find(java.lang.Class<T> entityClass,
                  java.lang.Object primaryKey,
                  LockModeType lockMode,
                  java.util.Map<java.lang.String,java.lang.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
    
    lockMode - lock mode
    
    properties - standard and vendor-specific properties and hints
    
    Returns:
    
    the found entity instance or null if the entity does not exist
  - getEntityManagerFactory
```
public EntityManagerFactory getEntityManagerFactory()
```
    Description copied from interface: EntityManager
    
    Return the entity manager factory for the entity manager.
    
    Specified by:
    
    getEntityManagerFactory in interface EntityManager
    
    Returns:
    
    EntityManagerFactory instance
  - getLockMode
```
public LockModeType getLockMode(java.lang.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
  - getMetamodel
```
public Metamodel getMetamodel()
```
    Description copied from interface: EntityManager
    
    Return an instance of Metamodel interface for access to the metamodel of the persistence unit.
    
    Specified by:
    
    getMetamodel in interface EntityManager
    
    Returns:
    
    Metamodel instance
  - getProperties
```
public java.util.Map<java.lang.String,java.lang.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
  - getCriteriaBuilder
```
public CriteriaBuilder getCriteriaBuilder()
```
    Description copied from interface: EntityManager
    
    Return an instance of CriteriaBuilder for the creation of CriteriaQuery objects.
    
    Specified by:
    
    getCriteriaBuilder in interface EntityManager
    
    Returns:
    
    CriteriaBuilder instance
  - lock
```
public void lock(java.lang.Object entity,
                 LockModeType lockMode,
                 java.util.Map<java.lang.String,java.lang.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
    
    lockMode - lock mode
    
    properties - standard and vendor-specific properties and hints
  - refresh
```
public void refresh(java.lang.Object entity,
                    java.util.Map<java.lang.String,java.lang.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(java.lang.Object entity,
                    LockModeType lockMode)
```
    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
    
    lockMode - lock mode
  - refresh
```
public void refresh(java.lang.Object entity,
                    LockModeType lockMode,
                    java.util.Map<java.lang.String,java.lang.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
    
    lockMode - lock mode
    
    properties - standard and vendor-specific properties and hints
  - setProperty
```
public void setProperty(java.lang.String name,
                        java.lang.Object value)
```
    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:
    
    name - name of property or hint
    
    value - value for property or hint
  - unwrap
```
public <T> T unwrap(java.lang.Class<T> cls)
```
    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:
    
    cls - 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
  - writeReplace
```
protected java.lang.Object writeReplace()
                                 throws java.io.ObjectStreamException
```
    Throws:
    
    java.io.ObjectStreamException
  - createNamedStoredProcedureQuery
```
public StoredProcedureQuery createNamedStoredProcedureQuery(java.lang.String name)
```
    Description copied from interface: EntityManager
    
    Create an instance of StoredProcedureQuery for executing a stored procedure in the database.
    Parameters must be registered before the stored procedure can be executed.
    If the stored procedure returns one or more result sets, any result set will be returned as a list of type Object[].
    
    Specified by:
    
    createNamedStoredProcedureQuery in interface EntityManager
    
    Parameters:
    
    name - name assigned to the stored procedure query in metadata
    
    Returns:
    
    the new stored procedure query instance
  - createStoredProcedureQuery
```
public StoredProcedureQuery createStoredProcedureQuery(java.lang.String procedureName)
```
    Description copied from interface: EntityManager
    
    Create an instance of StoredProcedureQuery for executing a stored procedure in the database.
    Parameters must be registered before the stored procedure can be executed.
    If the stored procedure returns one or more result sets, any result set will be returned as a list of type Object[].
    
    Specified by:
    
    createStoredProcedureQuery in interface EntityManager
    
    Parameters:
    
    procedureName - name of the stored procedure in the database
    
    Returns:
    
    the new stored procedure query instance
  - createStoredProcedureQuery
```
public StoredProcedureQuery createStoredProcedureQuery(java.lang.String procedureName,
                                                       java.lang.Class... resultClasses)
```
    Description copied from interface: EntityManager
    
    Create an instance of StoredProcedureQuery for executing a stored procedure in the database.
    Parameters must be registered before the stored procedure can be executed.
    The resultClass arguments must be specified in the order in which the result sets will be returned by the stored procedure invocation.
    
    Specified by:
    
    createStoredProcedureQuery in interface EntityManager
    
    Parameters:
    
    procedureName - name of the stored procedure in the database
    
    resultClasses - classes to which the result sets produced by the stored procedure are to be mapped
    
    Returns:
    
    the new stored procedure query instance
  - createStoredProcedureQuery
```
public StoredProcedureQuery createStoredProcedureQuery(java.lang.String procedureName,
                                                       java.lang.String... resultSetMappings)
```
    Description copied from interface: EntityManager
    
    Create an instance of StoredProcedureQuery for executing a stored procedure in the database.
    Parameters must be registered before the stored procedure can be executed.
    The resultSetMapping arguments must be specified in the order in which the result sets will be returned by the stored procedure invocation.
    
    Specified by:
    
    createStoredProcedureQuery in interface EntityManager
    
    Parameters:
    
    procedureName - name of the stored procedure in the database
    
    resultSetMappings - the names of the result set mappings to be used in mapping result sets returned by the stored procedure
    
    Returns:
    
    the new stored procedure query instance
  - createQuery
```
public Query createQuery(CriteriaUpdate updateQuery)
```
    Description copied from interface: EntityManager
    
    Create an instance of Query for executing a criteria update query.
    
    Specified by:
    
    createQuery in interface EntityManager
    
    Parameters:
    
    updateQuery - a criteria update query object
    
    Returns:
    
    the new query instance
  - createQuery
```
public Query createQuery(CriteriaDelete deleteQuery)
```
    Description copied from interface: EntityManager
    
    Create an instance of Query for executing a criteria delete query.
    
    Specified by:
    
    createQuery in interface EntityManager
    
    Parameters:
    
    deleteQuery - a criteria delete query object
    
    Returns:
    
    the new query instance
  - createEntityGraph
```
public <T> EntityGraph<T> createEntityGraph(java.lang.Class<T> rootType)
```
    Description copied from interface: EntityManager
    
    Return a mutable EntityGraph that can be used to dynamically create an EntityGraph.
    
    Specified by:
    
    createEntityGraph in interface EntityManager
    
    Parameters:
    
    rootType - class of entity graph
    
    Returns:
    
    entity graph
  - createEntityGraph
```
public EntityGraph<?> createEntityGraph(java.lang.String graphName)
```
    Description copied from interface: EntityManager
    
    Return a mutable copy of the named EntityGraph. If there is no entity graph with the specified name, null is returned.
    
    Specified by:
    
    createEntityGraph in interface EntityManager
    
    Parameters:
    
    graphName - name of an entity graph
    
    Returns:
    
    entity graph
  - getEntityGraph
```
public EntityGraph<?> getEntityGraph(java.lang.String graphName)
```
    Description copied from interface: EntityManager
    
    Return a named EntityGraph. The returned EntityGraph should be considered immutable.
    
    Specified by:
    
    getEntityGraph in interface EntityManager
    
    Parameters:
    
    graphName - name of an existing entity graph
    
    Returns:
    
    named entity graph
  - getEntityGraphs
```
public <T> java.util.List<EntityGraph<? super T>> getEntityGraphs(java.lang.Class<T> entityClass)
```
    Description copied from interface: EntityManager
    
    Return all named EntityGraphs that have been defined for the provided class type.
    
    Specified by:
    
    getEntityGraphs in interface EntityManager
    
    Parameters:
    
    entityClass - entity class
    
    Returns:
    
    list of all entity graphs defined for the entity
  - isJoinedToTransaction
```
public boolean isJoinedToTransaction()
```
    Description copied from interface: EntityManager
    
    Determine whether the entity manager is joined to the current transaction. Returns false if the entity manager is not joined to the current transaction or if no transaction is active
    
    Specified by:
    
    isJoinedToTransaction in interface EntityManager
    
    Returns:
    
    boolean

Class JtaEntityManager

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

JtaEntityManager

JtaEntityManager

Method Detail

isJPA21

getDelegate

persist

merge

remove

find

getReference

flush

setFlushMode

getFlushMode

lock

refresh

clear

contains

createQuery

createNamedQuery

createNativeQuery

createNativeQuery

createNativeQuery

joinTransaction

close

isOpen

getTransaction

createNamedQuery

createQuery

createQuery

detach

find

find

find

getEntityManagerFactory

getLockMode

getMetamodel

getProperties

getCriteriaBuilder

lock

refresh

refresh

refresh

setProperty

unwrap

writeReplace

createNamedStoredProcedureQuery

createStoredProcedureQuery

createStoredProcedureQuery

createStoredProcedureQuery

createQuery

createQuery

createEntityGraph

createEntityGraph

getEntityGraph

getEntityGraphs

isJoinedToTransaction