AbstractEntityManagerImpl (Hibernate Core Aggregator 3.6.10.Final API)

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

All Implemented Interfaces:

Serializable, javax.persistence.EntityManager, HibernateEntityManager, HibernateEntityManagerImplementor

Direct Known Subclasses:

CurrentEntityManagerImpl, 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 javax.persistence.PersistenceContextType persistenceContextType

protected TransactionImpl tx

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

Constructor Summary

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

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`clear()`
`boolean`	`contains(Object entity)`
`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)`
`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)`
`<T> javax.persistence.TypedQuery<T>`	`createQuery(javax.persistence.criteria.CriteriaQuery<T> criteriaQuery)`
`javax.persistence.Query`	`createQuery(String jpaqlString)`
`<T> javax.persistence.TypedQuery<T>`	`createQuery(String jpaqlString, Class<T> resultClass)`
`<T> javax.persistence.TypedQuery<T>`	`createQuery(String jpaqlString, Class<T> resultClass, javax.persistence.criteria.Selection selection, HibernateEntityManagerImplementor.Options options)` Used during "compiling" a JPA criteria query.
`void`	`detach(Object entity)`
`CacheMode`	`determineAppropriateLocalCacheMode(Map<String,Object> localProperties)`
`<A> A`	`find(Class<A> entityClass, Object primaryKey)`
`<A> A`	`find(Class<A> entityClass, Object primaryKey, javax.persistence.LockModeType lockModeType)`
`<A> A`	`find(Class<A> entityClass, Object primaryKey, javax.persistence.LockModeType lockModeType, Map<String,Object> properties)`
`<T> T`	`find(Class<T> entityClass, Object primaryKey, Map<String,Object> properties)`
`void`	`flush()`
`javax.persistence.criteria.CriteriaBuilder`	`getCriteriaBuilder()`
`Object`	`getDelegate()` returns the underlying session
`EntityManagerFactoryImpl`	`getEntityManagerFactory()`
`HibernateEntityManagerFactory`	`getFactory()` Get access to the Hibernate extended EMF contract.
`javax.persistence.FlushModeType`	`getFlushMode()` Hibernate can be set in various flush modes that are unknown to JPA 2.0.
`javax.persistence.LockModeType`	`getLockMode(Object entity)`
`LockOptions`	`getLockRequest(javax.persistence.LockModeType lockModeType, Map<String,Object> properties)` Convert from JPA 2 `LockModeType` & properties into `LockOptions`
`javax.persistence.metamodel.Metamodel`	`getMetamodel()`
`Map<String,Object>`	`getProperties()`
`protected abstract Session`	`getRawSession()` Return a Session (even if the entity manager is closed).
`<T> T`	`getReference(Class<T> entityClass, Object primaryKey)`
`abstract Session`	`getSession()` return a Session
`javax.persistence.EntityTransaction`	`getTransaction()`
`void`	`handlePersistenceException(javax.persistence.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()`
`void`	`lock(Object entity, javax.persistence.LockModeType lockMode)`
`void`	`lock(Object entity, javax.persistence.LockModeType lockModeType, Map<String,Object> properties)`
`protected void`	`markAsRollback()`
`<A> A`	`merge(A entity)`
`void`	`persist(Object entity)`
`protected void`	`postInit()`
`void`	`refresh(Object entity)`
`void`	`refresh(Object entity, javax.persistence.LockModeType lockModeType)`
`void`	`refresh(Object entity, javax.persistence.LockModeType lockModeType, Map<String,Object> properties)`
`void`	`refresh(Object entity, Map<String,Object> properties)`
`void`	`remove(Object entity)`
`void`	`setFlushMode(javax.persistence.FlushModeType flushModeType)`
`void`	`setProperty(String s, Object o)`
`void`	`throwPersistenceException(HibernateException e)` Delegates to `HibernateEntityManagerImplementor.convert(org.hibernate.HibernateException, org.hibernate.LockOptions)` and then throws the given exception.
`void`	`throwPersistenceException(javax.persistence.PersistenceException e)` Delegates to `HibernateEntityManagerImplementor.handlePersistenceException(javax.persistence.PersistenceException)` and then throws the given exception.
`<T> T`	`unwrap(Class<T> clazz)`
`javax.persistence.PersistenceException`	`wrapLockException(HibernateException e, LockOptions lockOptions)`
`javax.persistence.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 javax.persistence.PersistenceContextType persistenceContextType
```
- Constructor Detail
  - AbstractEntityManagerImpl
```
protected AbstractEntityManagerImpl(EntityManagerFactoryImpl entityManagerFactory,
                         javax.persistence.PersistenceContextType type,
                         javax.persistence.spi.PersistenceUnitTransactionType transactionType,
                         Map properties)
```
- Method Detail
  - postInit
```
protected void postInit()
```
  - createQuery
```
public javax.persistence.Query createQuery(String jpaqlString)
```
    Specified by:
    
    createQuery in interface javax.persistence.EntityManager
  - createQuery
```
public <T> javax.persistence.TypedQuery<T> createQuery(String jpaqlString,
                                              Class<T> resultClass)
```
    Specified by:
    
    createQuery in interface javax.persistence.EntityManager
  - createQuery
```
public <T> javax.persistence.TypedQuery<T> createQuery(String jpaqlString,
                                              Class<T> resultClass,
                                              javax.persistence.criteria.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> javax.persistence.TypedQuery<T> createQuery(javax.persistence.criteria.CriteriaQuery<T> criteriaQuery)
```
    Specified by:
    
    createQuery 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
  - getReference
```
public <T> T getReference(Class<T> entityClass,
                 Object primaryKey)
```
    Specified by:
    
    getReference in interface javax.persistence.EntityManager
  - find
```
public <A> A find(Class<A> entityClass,
         Object primaryKey)
```
    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
  - find
```
public <A> A find(Class<A> entityClass,
         Object primaryKey,
         javax.persistence.LockModeType lockModeType)
```
    Specified by:
    
    find in interface javax.persistence.EntityManager
  - find
```
public <A> A find(Class<A> entityClass,
         Object primaryKey,
         javax.persistence.LockModeType lockModeType,
         Map<String,Object> properties)
```
    Specified by:
    
    find in interface javax.persistence.EntityManager
  - determineAppropriateLocalCacheMode
```
public CacheMode determineAppropriateLocalCacheMode(Map<String,Object> localProperties)
```
  - persist
```
public void persist(Object entity)
```
    Specified by:
    
    persist in interface javax.persistence.EntityManager
  - merge
```
public <A> A merge(A entity)
```
    Specified by:
    
    merge in interface javax.persistence.EntityManager
  - remove
```
public void remove(Object entity)
```
    Specified by:
    
    remove in interface javax.persistence.EntityManager
  - refresh
```
public void refresh(Object entity)
```
    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
  - refresh
```
public void refresh(Object entity,
           javax.persistence.LockModeType lockModeType)
```
    Specified by:
    
    refresh in interface javax.persistence.EntityManager
  - refresh
```
public void refresh(Object entity,
           javax.persistence.LockModeType lockModeType,
           Map<String,Object> properties)
```
    Specified by:
    
    refresh in interface javax.persistence.EntityManager
  - contains
```
public boolean contains(Object entity)
```
    Specified by:
    
    contains in interface javax.persistence.EntityManager
  - getLockMode
```
public javax.persistence.LockModeType getLockMode(Object entity)
```
    Specified by:
    
    getLockMode in interface javax.persistence.EntityManager
  - setProperty
```
public void setProperty(String s,
               Object o)
```
    Specified by:
    
    setProperty in interface javax.persistence.EntityManager
  - getProperties
```
public Map<String,Object> getProperties()
```
    Specified by:
    
    getProperties in interface javax.persistence.EntityManager
  - flush
```
public void flush()
```
    Specified by:
    
    flush in interface javax.persistence.EntityManager
  - getSession
```
public abstract Session getSession()
```
    return a Session
    
    Specified by:
    
    getSession in interface HibernateEntityManager
    
    Returns:
    
    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 javax.persistence.EntityTransaction getTransaction()
```
    Specified by:
    
    getTransaction in interface javax.persistence.EntityManager
  - getEntityManagerFactory
```
public EntityManagerFactoryImpl getEntityManagerFactory()
```
    Specified by:
    
    getEntityManagerFactory in interface javax.persistence.EntityManager
  - 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 javax.persistence.criteria.CriteriaBuilder getCriteriaBuilder()
```
    Specified by:
    
    getCriteriaBuilder in interface javax.persistence.EntityManager
  - getMetamodel
```
public javax.persistence.metamodel.Metamodel getMetamodel()
```
    Specified by:
    
    getMetamodel in interface javax.persistence.EntityManager
  - setFlushMode
```
public void setFlushMode(javax.persistence.FlushModeType flushModeType)
```
    Specified by:
    
    setFlushMode in interface javax.persistence.EntityManager
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface javax.persistence.EntityManager
  - detach
```
public void detach(Object entity)
```
    Specified by:
    
    detach in interface javax.persistence.EntityManager
  - getFlushMode
```
public javax.persistence.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 javax.persistence.EntityManager
  - 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 lockModeType,
        Map<String,Object> properties)
```
    Specified by:
    
    lock in interface javax.persistence.EntityManager
  - getLockRequest
```
public LockOptions getLockRequest(javax.persistence.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()
```
    Specified by:
    
    joinTransaction in interface javax.persistence.EntityManager
  - unwrap
```
public <T> T unwrap(Class<T> clazz)
```
    Specified by:
    
    unwrap in interface javax.persistence.EntityManager
  - getDelegate
```
public Object getDelegate()
```
    returns the underlying session
    
    Specified by:
    
    getDelegate in interface javax.persistence.EntityManager
  - handlePersistenceException
```
public void handlePersistenceException(javax.persistence.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(javax.persistence.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 javax.persistence.PersistenceException wrapStaleStateException(StaleStateException e)
```
    Specified by:
    
    wrapStaleStateException in interface HibernateEntityManagerImplementor
  - wrapLockException
```
public javax.persistence.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

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