EntityManagerImpl (Batoo Persistence Core 2.0.0.RC1 API)

java.lang.Object
- org.batoo.jpa.core.impl.manager.EntityManagerImpl

All Implemented Interfaces:

javax.persistence.EntityManager

Direct Known Subclasses:

JtaEntityManagerImpl
```
public class EntityManagerImpl
extends Object
implements javax.persistence.EntityManager
```
Implementation of EntityManager.

Since:

$version

Author:

hceylan

Constructor Summary

Constructors
Constructor and Description
`EntityManagerImpl(EntityManagerFactoryImpl entityManagerFactory, MetamodelImpl metamodel, DataSource datasource, Map<String,Object> properties, JdbcAdaptor jdbcAdaptor)`

Method Summary

Methods
Modifier and Type	Method and Description
`protected void`	`assertOpen()` Checks if the entity manager is open.
`void`	`assertTransaction()` Asserts that a transaction is active.
`<T> void`	`cascadeMerge(EntityTypeImpl<T> type, T entity, org.apache.commons.lang.mutable.MutableBoolean requiresFlush, IdentityHashMap<Object,Object> processed)` Cascades the merge operation
`void`	`clear()`
`void`	`clearTransaction()` Clears the transaction.
`void`	`close()`
`protected void`	`closeConnection()` Closes the database connection.
`void`	`closeConnectionIfNecessary()` Closes the connection if the connections is obtained from JTA managed datasource.
`boolean`	`contains(Object entity)`
`javax.persistence.Query`	`createNamedQuery(String name)`
`<T> javax.persistence.TypedQuery<T>`	`createNamedQuery(String name, Class<T> resultClass)`
`javax.persistence.Query`	`createNativeQuery(String sqlString)`
`javax.persistence.Query`	`createNativeQuery(String sqlString, Class<?> resultClass)`
`javax.persistence.Query`	`createNativeQuery(String sqlString, String resultSetMapping)`
`javax.persistence.Query`	`createQuery(CriteriaDeleteImpl<?> deleteQuery)`
`<T> QueryImpl<T>`	`createQuery(javax.persistence.criteria.CriteriaQuery<T> criteriaQuery)`
`javax.persistence.Query`	`createQuery(CriteriaUpdateImpl<?> updateQuery)`
`javax.persistence.Query`	`createQuery(String qlString)`
`<T> javax.persistence.TypedQuery<T>`	`createQuery(String qlString, Class<T> resultClass)`
`void`	`detach(Object entity)`
`<T> T`	`find(Class<T> entityClass, Object primaryKey)`
`<T> T`	`find(Class<T> entityClass, Object primaryKey, javax.persistence.LockModeType lockMode)`
`<T> T`	`find(Class<T> entityClass, Object primaryKey, javax.persistence.LockModeType lockMode, Map<String,Object> properties)`
`<T> T`	`find(Class<T> entityClass, Object primaryKey, Map<String,Object> properties)`
`void`	`flush()`
`Connection`	`getConnection()` Returns the active connection.
`CriteriaBuilderImpl`	`getCriteriaBuilder()`
`Object`	`getDelegate()`
`EntityManagerFactoryImpl`	`getEntityManagerFactory()`
`javax.persistence.FlushModeType`	`getFlushMode()`
`JdbcAdaptor`	`getJdbcAdaptor()` Returns the JDBC adaptor.
`javax.persistence.LockModeType`	`getLockMode(Object entity)`
`MetamodelImpl`	`getMetamodel()`
`Map<String,Object>`	`getProperties()`
`<T> T`	`getReference(Class<T> entityClass, Object primaryKey)`
`SessionImpl`	`getSession()` Returns the session.
`EntityTransactionImpl`	`getTransaction()`
`boolean`	`hasTransactionMarkedForRollback()` Returns if the entity manager has a transaction which is marked for rollback.
`boolean`	`isJoinedToTransaction()`
`boolean`	`isOpen()`
`void`	`isValid(EntityTransactionImpl transaction)` Check if the transaction is valid and belongs to this entity manager.
`void`	`joinTransaction()`
`void`	`lock(ManagedInstance<?> instance, javax.persistence.LockModeType lockMode, Map<String,Object> properties)` Locks the entity.
`void`	`lock(Object entity, javax.persistence.LockModeType lockMode)`
`void`	`lock(Object entity, javax.persistence.LockModeType lockMode, Map<String,Object> properties)`
`<T> T`	`merge(T entity)`
`<T> T`	`mergeImpl(T entity, org.apache.commons.lang.mutable.MutableBoolean requiresFlush, IdentityHashMap<Object,Object> processed, boolean cascade)` Cascaded implementation of `merge(Object)`.
`void`	`persist(Object entity)`
`<T> boolean`	`persistImpl(T entity, ArrayList<Object> processed)` Cascaded implementation of `persist(Object)`.
`void`	`refresh(Object entity)`
`void`	`refresh(Object entity, javax.persistence.LockModeType lockMode)`
`void`	`refresh(Object entity, javax.persistence.LockModeType lockMode, Map<String,Object> properties)`
`void`	`refresh(Object entity, Map<String,Object> properties)`
`ManagedInstance<?>`	`refreshImpl(Object entity, javax.persistence.LockModeType lockMode, Set<Object> processed)` Recursive refresh implementation.
`void`	`remove(Object entity)`
`void`	`setFlushMode(javax.persistence.FlushModeType flushMode)`
`void`	`setProperty(String propertyName, Object value)`
`<T> T`	`unwrap(Class<T> clazz)`

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

- Constructor Detail
  - EntityManagerImpl
```
public EntityManagerImpl(EntityManagerFactoryImpl entityManagerFactory,
                 MetamodelImpl metamodel,
                 DataSource datasource,
                 Map<String,Object> properties,
                 JdbcAdaptor jdbcAdaptor)
```
    Parameters:
    entityManagerFactory - the entity manager factory
    metamodel - the metamodel
    datasource - the datasource
    properties - properties for the entity manager
    jdbcAdaptor - the JDBC adaptor
    Since:
    
    $version
- Method Detail
  - assertOpen
```
protected void assertOpen()
```
    Checks if the entity manager is open.
    
    Since:
    
    $version
  - assertTransaction
```
public void assertTransaction()
```
    Asserts that a transaction is active.
    
    Since:
    
    $version
  - cascadeMerge
```
public <T> void cascadeMerge(EntityTypeImpl<T> type,
                    T entity,
                    org.apache.commons.lang.mutable.MutableBoolean requiresFlush,
                    IdentityHashMap<Object,Object> processed)
```
    Cascades the merge operation
    
    Type Parameters:
    T - the type of the entity
    Parameters:
    type - the entity type
    entity - the entity
    requiresFlush - if an implicit flush is required
    processed - registry of processed entities
    Since:
    
    $version
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface javax.persistence.EntityManager
  - clearTransaction
```
public void clearTransaction()
```
    Clears the transaction.
    
    Since:
    
    $version
  - close
```
public void close()
```
    Specified by:
    
    close in interface javax.persistence.EntityManager
  - closeConnection
```
protected void closeConnection()
```
    Closes the database connection.
    
    Since:
    
    $version
  - closeConnectionIfNecessary
```
public void closeConnectionIfNecessary()
```
    Closes the connection if the connections is obtained from JTA managed datasource.
    
    Since:
    
    $version
  - contains
```
public boolean contains(Object entity)
```
    Specified by:
    
    contains in interface javax.persistence.EntityManager
  - createNamedQuery
```
public javax.persistence.Query createNamedQuery(String name)
```
    Specified by:
    
    createNamedQuery in interface javax.persistence.EntityManager
  - createNamedQuery
```
public <T> javax.persistence.TypedQuery<T> createNamedQuery(String name,
                                                   Class<T> resultClass)
```
    Specified by:
    
    createNamedQuery in interface javax.persistence.EntityManager
  - createNativeQuery
```
public javax.persistence.Query createNativeQuery(String sqlString)
```
    Specified by:
    
    createNativeQuery in interface javax.persistence.EntityManager
  - createNativeQuery
```
public javax.persistence.Query createNativeQuery(String sqlString,
                                        Class<?> resultClass)
```
    Specified by:
    
    createNativeQuery in interface javax.persistence.EntityManager
  - createNativeQuery
```
public javax.persistence.Query createNativeQuery(String sqlString,
                                        String resultSetMapping)
```
    Specified by:
    
    createNativeQuery in interface javax.persistence.EntityManager
  - createQuery
```
public javax.persistence.Query createQuery(CriteriaDeleteImpl<?> deleteQuery)
```
  - createQuery
```
public <T> QueryImpl<T> createQuery(javax.persistence.criteria.CriteriaQuery<T> criteriaQuery)
```
    Specified by:
    
    createQuery in interface javax.persistence.EntityManager
  - createQuery
```
public javax.persistence.Query createQuery(CriteriaUpdateImpl<?> updateQuery)
```
  - createQuery
```
public javax.persistence.Query createQuery(String qlString)
```
    Specified by:
    
    createQuery in interface javax.persistence.EntityManager
  - createQuery
```
public <T> javax.persistence.TypedQuery<T> createQuery(String qlString,
                                              Class<T> resultClass)
```
    Specified by:
    
    createQuery in interface javax.persistence.EntityManager
  - detach
```
public void detach(Object entity)
```
    Specified by:
    
    detach in interface javax.persistence.EntityManager
  - find
```
public <T> T find(Class<T> entityClass,
         Object primaryKey)
```
    Specified by:
    
    find in interface javax.persistence.EntityManager
  - find
```
public <T> T find(Class<T> entityClass,
         Object primaryKey,
         javax.persistence.LockModeType lockMode)
```
    Specified by:
    
    find in interface javax.persistence.EntityManager
  - find
```
public <T> T find(Class<T> entityClass,
         Object primaryKey,
         javax.persistence.LockModeType lockMode,
         Map<String,Object> properties)
```
    Specified by:
    
    find in interface javax.persistence.EntityManager
  - find
```
public <T> T find(Class<T> entityClass,
         Object primaryKey,
         Map<String,Object> properties)
```
    Specified by:
    
    find in interface javax.persistence.EntityManager
  - flush
```
public void flush()
```
    Specified by:
    
    flush in interface javax.persistence.EntityManager
  - getConnection
```
public Connection getConnection()
```
    Returns the active connection.
    
    Returns:
    the connection
    Since:
    
    $version
  - getCriteriaBuilder
```
public CriteriaBuilderImpl getCriteriaBuilder()
```
    Specified by:
    
    getCriteriaBuilder in interface javax.persistence.EntityManager
  - getDelegate
```
public Object getDelegate()
```
    Specified by:
    
    getDelegate in interface javax.persistence.EntityManager
  - getEntityManagerFactory
```
public EntityManagerFactoryImpl getEntityManagerFactory()
```
    Specified by:
    
    getEntityManagerFactory in interface javax.persistence.EntityManager
  - getFlushMode
```
public javax.persistence.FlushModeType getFlushMode()
```
    Specified by:
    
    getFlushMode in interface javax.persistence.EntityManager
  - getJdbcAdaptor
```
public JdbcAdaptor getJdbcAdaptor()
```
    Returns the JDBC adaptor.
    
    Returns:
    the JDBC adaptor
    Since:
    
    $version
  - getLockMode
```
public javax.persistence.LockModeType getLockMode(Object entity)
```
    Specified by:
    
    getLockMode in interface javax.persistence.EntityManager
  - getMetamodel
```
public MetamodelImpl getMetamodel()
```
    Specified by:
    
    getMetamodel in interface javax.persistence.EntityManager
  - getProperties
```
public Map<String,Object> getProperties()
```
    Specified by:
    
    getProperties in interface javax.persistence.EntityManager
  - getReference
```
public <T> T getReference(Class<T> entityClass,
                 Object primaryKey)
```
    Specified by:
    
    getReference in interface javax.persistence.EntityManager
  - getSession
```
public SessionImpl getSession()
```
    Returns the session.
    
    Returns:
    the session
    Since:
    
    $version
  - getTransaction
```
public EntityTransactionImpl getTransaction()
```
    Specified by:
    
    getTransaction in interface javax.persistence.EntityManager
  - hasTransactionMarkedForRollback
```
public boolean hasTransactionMarkedForRollback()
```
    Returns if the entity manager has a transaction which is marked for rollback.
    
    Returns:
    true if the entity manager has a transaction which is marked for rollback, false otherwise
    Since:
    
    $version
  - isJoinedToTransaction
```
public boolean isJoinedToTransaction()
```
    Specified by:
    
    isJoinedToTransaction in interface javax.persistence.EntityManager
  - isOpen
```
public boolean isOpen()
```
    Specified by:
    
    isOpen in interface javax.persistence.EntityManager
  - isValid
```
public void isValid(EntityTransactionImpl transaction)
```
    Check if the transaction is valid and belongs to this entity manager.
    
    Parameters:
    transaction - the transaction to test the validity
    Since:
    
    $version
  - joinTransaction
```
public void joinTransaction()
```
    Specified by:
    
    joinTransaction in interface javax.persistence.EntityManager
  - lock
```
public void lock(ManagedInstance<?> instance,
        javax.persistence.LockModeType lockMode,
        Map<String,Object> properties)
```
    Locks the entity.
    
    Parameters:
    instance - the managed instance
    lockMode - the lock mode
    properties - the properties
    Since:
    
    $version
  - lock
```
public void lock(Object entity,
        javax.persistence.LockModeType lockMode)
```
    Specified by:
    
    lock in interface javax.persistence.EntityManager
  - lock
```
public void lock(Object entity,
        javax.persistence.LockModeType lockMode,
        Map<String,Object> properties)
```
    Specified by:
    
    lock in interface javax.persistence.EntityManager
  - merge
```
public <T> T merge(T entity)
```
    Specified by:
    
    merge in interface javax.persistence.EntityManager
  - mergeImpl
```
public <T> T mergeImpl(T entity,
              org.apache.commons.lang.mutable.MutableBoolean requiresFlush,
              IdentityHashMap<Object,Object> processed,
              boolean cascade)
```
    Cascaded implementation of merge(Object).
    Also manages a direct or indirect requirement to an implicit flush.
    
    Type Parameters:
    T - the type of the entity
    Parameters:
    entity - the entity to cascade
    requiresFlush - if an implicit flush is required
    processed - registry of processed entities
    cascade - cascades the merge operation
    
    Returns:
    true if an implicit flush is required, false otherwise
    Since:
    
    $version
  - persist
```
public void persist(Object entity)
```
    Specified by:
    
    persist in interface javax.persistence.EntityManager
  - persistImpl
```
public <T> boolean persistImpl(T entity,
                      ArrayList<Object> processed)
```
    Cascaded implementation of persist(Object).
    Also manages a direct or indirect requirement to an implicit flush.
    
    Type Parameters:
    T - the type of the entity
    Parameters:
    entity - the entity to cascade
    processed - registry of processed entities
    
    Returns:
    true if an implicit flush is required, false otherwise
    Since:
    
    $version
  - refresh
```
public void refresh(Object entity)
```
    Specified by:
    
    refresh in interface javax.persistence.EntityManager
  - refresh
```
public void refresh(Object entity,
           javax.persistence.LockModeType lockMode)
```
    Specified by:
    
    refresh in interface javax.persistence.EntityManager
  - refresh
```
public void refresh(Object entity,
           javax.persistence.LockModeType lockMode,
           Map<String,Object> properties)
```
    Specified by:
    
    refresh in interface javax.persistence.EntityManager
  - refresh
```
public void refresh(Object entity,
           Map<String,Object> properties)
```
    Specified by:
    
    refresh in interface javax.persistence.EntityManager
  - refreshImpl
```
public ManagedInstance<?> refreshImpl(Object entity,
                             javax.persistence.LockModeType lockMode,
                             Set<Object> processed)
```
    Recursive refresh implementation.
    
    Parameters:
    entity - the entity to refresh
    lockMode - the lock mode
    processed - registry of processed entities
    
    Returns:
    the managed instance
    Since:
    
    $version
  - remove
```
public void remove(Object entity)
```
    Specified by:
    
    remove in interface javax.persistence.EntityManager
  - setFlushMode
```
public void setFlushMode(javax.persistence.FlushModeType flushMode)
```
    Specified by:
    
    setFlushMode in interface javax.persistence.EntityManager
  - setProperty
```
public void setProperty(String propertyName,
               Object value)
```
    Specified by:
    
    setProperty in interface javax.persistence.EntityManager
  - unwrap
```
public <T> T unwrap(Class<T> clazz)
```
    Specified by:
    
    unwrap in interface javax.persistence.EntityManager

Class EntityManagerImpl

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

EntityManagerImpl

Method Detail

assertOpen

assertTransaction

cascadeMerge

clear

clearTransaction

close

closeConnection

closeConnectionIfNecessary

contains

createNamedQuery

createNamedQuery

createNativeQuery

createNativeQuery

createNativeQuery

createQuery

createQuery

createQuery

createQuery

createQuery

detach

find

find

find

find

flush

getConnection

getCriteriaBuilder

getDelegate

getEntityManagerFactory

getFlushMode

getJdbcAdaptor

getLockMode

getMetamodel

getProperties

getReference

getSession

getTransaction

hasTransactionMarkedForRollback

isJoinedToTransaction

isOpen

isValid

joinTransaction

lock

lock

lock

merge

mergeImpl

persist

persistImpl

refresh

refresh

refresh

refresh

refreshImpl

remove

setFlushMode

setProperty

unwrap