public class HibernateJpaDialect extends DefaultJpaDialect
JpaDialect
implementation for
Hibernate EntityManager. Developed against Hibernate 3.3;
tested against 3.3, 3.5, 3.6 and 4.0 (with the latter including
Hibernate EntityManager in the Hibernate core distribution).Modifier and Type | Class and Description |
---|---|
private static class |
HibernateJpaDialect.HibernateConnectionHandle |
private static class |
HibernateJpaDialect.SessionTransactionData |
Constructor and Description |
---|
HibernateJpaDialect() |
Modifier and Type | Method and Description |
---|---|
java.lang.Object |
beginTransaction(EntityManager entityManager,
TransactionDefinition definition)
This implementation invokes the standard JPA
Transaction.begin
method. |
void |
cleanupTransaction(java.lang.Object transactionData)
This implementation does nothing, since the default
beginTransaction
implementation does not require any cleanup. |
ConnectionHandle |
getJdbcConnection(EntityManager entityManager,
boolean readOnly)
This implementation always returns
null ,
indicating that no JDBC Connection can be provided. |
protected Session |
getSession(EntityManager em) |
java.lang.Object |
prepareTransaction(EntityManager entityManager,
boolean readOnly,
java.lang.String name)
Prepare a JPA transaction, applying the specified semantics.
|
DataAccessException |
translateExceptionIfPossible(java.lang.RuntimeException ex)
This implementation delegates to EntityManagerFactoryUtils.
|
getEntityManagerFactoryPlusOperations, getEntityManagerPlusOperations, releaseJdbcConnection, supportsEntityManagerFactoryPlusOperations, supportsEntityManagerPlusOperations
public java.lang.Object beginTransaction(EntityManager entityManager, TransactionDefinition definition) throws PersistenceException, java.sql.SQLException, TransactionException
DefaultJpaDialect
Transaction.begin
method. Throws an InvalidIsolationLevelException if a non-default isolation
level is set.
This implementation does not return any transaction data Object, since there
is no state to be kept for a standard JPA transaction. Hence, subclasses do not
have to care about the return value (null
) of this implementation
and are free to return their own transaction data Object.
beginTransaction
in interface JpaDialect
beginTransaction
in class DefaultJpaDialect
entityManager
- the EntityManager to begin a JPA transaction ondefinition
- the Spring transaction definition that defines semanticsJpaDialect.cleanupTransaction(java.lang.Object)
). May implement the
SavepointManager
interface.java.sql.SQLException
- if thrown by JDBC methodsTransactionException
- in case of invalid argumentsPersistenceException
javax.persistence.EntityTransaction#begin
,
InvalidIsolationLevelException
,
DefaultJpaDialect.cleanupTransaction(java.lang.Object)
public java.lang.Object prepareTransaction(EntityManager entityManager, boolean readOnly, java.lang.String name) throws PersistenceException
JpaDialect
An implementation can apply the read-only flag as flush mode. In that case,
a transaction data object can be returned that holds the previous flush mode
(and possibly other data), to be reset in cleanupTransaction
.
Implementations can also use the Spring transaction name, as exposed by the passed-in TransactionDefinition, to optimize for specific data access use cases (effectively using the current transaction name as use case identifier).
prepareTransaction
in interface JpaDialect
prepareTransaction
in class DefaultJpaDialect
entityManager
- the EntityManager to begin a JPA transaction onreadOnly
- whether the transaction is supposed to be read-onlyname
- the name of the transaction (if any)PersistenceException
JpaDialect.cleanupTransaction(java.lang.Object)
public void cleanupTransaction(java.lang.Object transactionData)
DefaultJpaDialect
beginTransaction
implementation does not require any cleanup.cleanupTransaction
in interface JpaDialect
cleanupTransaction
in class DefaultJpaDialect
transactionData
- arbitrary object that holds transaction data, if any
(as returned by beginTransaction or prepareTransaction)DefaultJpaDialect.beginTransaction(EntityManager, org.springframework.transaction.TransactionDefinition)
public ConnectionHandle getJdbcConnection(EntityManager entityManager, boolean readOnly) throws PersistenceException, java.sql.SQLException
DefaultJpaDialect
null
,
indicating that no JDBC Connection can be provided.getJdbcConnection
in interface JpaDialect
getJdbcConnection
in class DefaultJpaDialect
entityManager
- the current JPA EntityManagerreadOnly
- whether the Connection is only needed for read-only purposesreleaseJdbcConnection
, or null
if no JDBC Connection can be retrievedjava.sql.SQLException
- if thrown by JDBC methodsPersistenceException
JpaDialect.releaseJdbcConnection(org.springframework.jdbc.datasource.ConnectionHandle, EntityManager)
,
ConnectionHandle.getConnection()
,
SimpleConnectionHandle
,
JpaTransactionManager.setDataSource(javax.sql.DataSource)
,
NativeJdbcExtractor
public DataAccessException translateExceptionIfPossible(java.lang.RuntimeException ex)
DefaultJpaDialect
translateExceptionIfPossible
in interface PersistenceExceptionTranslator
translateExceptionIfPossible
in class DefaultJpaDialect
ex
- a RuntimeException thrownnull
if the
exception could not be translated, as in this case it may result from
user code rather than an actual persistence problem)EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(java.lang.RuntimeException)
protected Session getSession(EntityManager em)