EntityManagerImpl (Batoo Persistence Core 0.1.2 API)

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

All Implemented Interfaces:

EntityManager

Direct Known Subclasses:

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

Since:

$version

Author:

hceylan

Constructor Summary

Constructors
Constructor and Description
`EntityManagerImpl(EntityManagerFactoryImpl entityManagerFactory, MetamodelImpl metamodel, DataSourceImpl 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)`
`Query`	`createNamedQuery(String name)`
`<T> TypedQuery<T>`	`createNamedQuery(String name, Class<T> resultClass)`
`Query`	`createNativeQuery(String sqlString)`
`Query`	`createNativeQuery(String sqlString, Class<?> resultClass)`
`Query`	`createNativeQuery(String sqlString, String resultSetMapping)`
`Query`	`createQuery(CriteriaDeleteImpl<?> deleteQuery)`
`<T> QueryImpl<T>`	`createQuery(CriteriaQuery<T> criteriaQuery)`
`Query`	`createQuery(CriteriaUpdateImpl<?> updateQuery)`
`Query`	`createQuery(String qlString)`
`<T> 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, LockModeType lockMode)`
`<T> T`	`find(Class<T> entityClass, Object primaryKey, LockModeType lockMode, Map<String,Object> properties)`
`<T> T`	`find(Class<T> entityClass, Object primaryKey, Map<String,Object> properties)`
`void`	`flush()`
`ConnectionImpl`	`getConnection()` Returns the active connection.
`CriteriaBuilderImpl`	`getCriteriaBuilder()`
`Object`	`getDelegate()`
`EntityManagerFactoryImpl`	`getEntityManagerFactory()`
`FlushModeType`	`getFlushMode()`
`JdbcAdaptor`	`getJdbcAdaptor()` Returns the JDBC adaptor.
`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, LockModeType lockMode, Map<String,Object> properties)` Locks the entity.
`void`	`lock(Object entity, LockModeType lockMode)`
`void`	`lock(Object entity, 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, LockModeType lockMode)`
`void`	`refresh(Object entity, LockModeType lockMode, Map<String,Object> properties)`
`void`	`refresh(Object entity, Map<String,Object> properties)`
`void`	`remove(Object entity)`
`void`	`setFlushMode(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,
                 DataSourceImpl 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 EntityManager
  - clearTransaction
```
public void clearTransaction()
```
    Clears the transaction.
    
    Since:
    
    $version
  - close
```
public void close()
```
    Specified by:
    
    close in interface 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 EntityManager
  - createNamedQuery
```
public Query createNamedQuery(String name)
```
    Specified by:
    
    createNamedQuery in interface EntityManager
  - createNamedQuery
```
public <T> TypedQuery<T> createNamedQuery(String name,
                                 Class<T> resultClass)
```
    Specified by:
    
    createNamedQuery in interface EntityManager
  - createNativeQuery
```
public Query createNativeQuery(String sqlString)
```
    Specified by:
    
    createNativeQuery in interface EntityManager
  - createNativeQuery
```
public Query createNativeQuery(String sqlString,
                      Class<?> resultClass)
```
    Specified by:
    
    createNativeQuery in interface EntityManager
  - createNativeQuery
```
public Query createNativeQuery(String sqlString,
                      String resultSetMapping)
```
    Specified by:
    
    createNativeQuery in interface EntityManager
  - createQuery
```
public Query createQuery(CriteriaDeleteImpl<?> deleteQuery)
```
  - createQuery
```
public <T> QueryImpl<T> createQuery(CriteriaQuery<T> criteriaQuery)
```
    Specified by:
    
    createQuery in interface EntityManager
  - createQuery
```
public Query createQuery(CriteriaUpdateImpl<?> updateQuery)
```
  - createQuery
```
public Query createQuery(String qlString)
```
    Specified by:
    
    createQuery in interface EntityManager
  - createQuery
```
public <T> TypedQuery<T> createQuery(String qlString,
                            Class<T> resultClass)
```
    Specified by:
    
    createQuery in interface EntityManager
  - detach
```
public void detach(Object entity)
```
    Specified by:
    
    detach in interface EntityManager
  - find
```
public <T> T find(Class<T> entityClass,
         Object primaryKey)
```
    Specified by:
    
    find in interface EntityManager
  - find
```
public <T> T find(Class<T> entityClass,
         Object primaryKey,
         LockModeType lockMode)
```
    Specified by:
    
    find in interface EntityManager
  - find
```
public <T> T find(Class<T> entityClass,
         Object primaryKey,
         LockModeType lockMode,
         Map<String,Object> properties)
```
    Specified by:
    
    find in interface EntityManager
  - find
```
public <T> T find(Class<T> entityClass,
         Object primaryKey,
         Map<String,Object> properties)
```
    Specified by:
    
    find in interface EntityManager
  - flush
```
public void flush()
```
    Specified by:
    
    flush in interface EntityManager
  - getConnection
```
public ConnectionImpl getConnection()
```
    Returns the active connection.
    
    Returns:
    the connection
    Since:
    
    $version
  - getCriteriaBuilder
```
public CriteriaBuilderImpl getCriteriaBuilder()
```
    Specified by:
    
    getCriteriaBuilder in interface EntityManager
  - getDelegate
```
public Object getDelegate()
```
    Specified by:
    
    getDelegate in interface EntityManager
  - getEntityManagerFactory
```
public EntityManagerFactoryImpl getEntityManagerFactory()
```
    Specified by:
    
    getEntityManagerFactory in interface EntityManager
  - getFlushMode
```
public FlushModeType getFlushMode()
```
    Specified by:
    
    getFlushMode in interface EntityManager
  - getJdbcAdaptor
```
public JdbcAdaptor getJdbcAdaptor()
```
    Returns the JDBC adaptor.
    
    Returns:
    the JDBC adaptor
    Since:
    
    $version
  - getLockMode
```
public LockModeType getLockMode(Object entity)
```
    Specified by:
    
    getLockMode in interface EntityManager
  - getMetamodel
```
public MetamodelImpl getMetamodel()
```
    Specified by:
    
    getMetamodel in interface EntityManager
  - getProperties
```
public Map<String,Object> getProperties()
```
    Specified by:
    
    getProperties in interface EntityManager
  - getReference
```
public <T> T getReference(Class<T> entityClass,
                 Object primaryKey)
```
    Specified by:
    
    getReference in interface EntityManager
  - getSession
```
public SessionImpl getSession()
```
    Returns the session.
    
    Returns:
    the session
    Since:
    
    $version
  - getTransaction
```
public EntityTransactionImpl getTransaction()
```
    Specified by:
    
    getTransaction in interface 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 EntityManager
  - isOpen
```
public boolean isOpen()
```
    Specified by:
    
    isOpen in interface 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 EntityManager
  - lock
```
public void lock(ManagedInstance<?> instance,
        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,
        LockModeType lockMode)
```
    Specified by:
    
    lock in interface EntityManager
  - lock
```
public void lock(Object entity,
        LockModeType lockMode,
        Map<String,Object> properties)
```
    Specified by:
    
    lock in interface EntityManager
  - merge
```
public <T> T merge(T entity)
```
    Specified by:
    
    merge in interface 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 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 EntityManager
  - refresh
```
public void refresh(Object entity,
           LockModeType lockMode)
```
    Specified by:
    
    refresh in interface EntityManager
  - refresh
```
public void refresh(Object entity,
           LockModeType lockMode,
           Map<String,Object> properties)
```
    Specified by:
    
    refresh in interface EntityManager
  - refresh
```
public void refresh(Object entity,
           Map<String,Object> properties)
```
    Specified by:
    
    refresh in interface EntityManager
  - remove
```
public void remove(Object entity)
```
    Specified by:
    
    remove in interface EntityManager
  - setFlushMode
```
public void setFlushMode(FlushModeType flushMode)
```
    Specified by:
    
    setFlushMode in interface EntityManager
  - setProperty
```
public void setProperty(String propertyName,
               Object value)
```
    Specified by:
    
    setProperty in interface EntityManager
  - unwrap
```
public <T> T unwrap(Class<T> clazz)
```
    Specified by:
    
    unwrap in interface 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

remove

setFlushMode

setProperty

unwrap