org.springframework.orm.jpa.vendor

## Class HibernateJpaDialect

- java.lang.Object
- - org.springframework.orm.jpa.DefaultJpaDialect
  - - org.springframework.orm.jpa.vendor.HibernateJpaDialect

All Implemented Interfaces:
  Serializable, PersistenceExceptionTranslator, JpaDialect

    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).

Since:
  2.0
Author:
  Costin Leau, Juergen Hoeller
See Also:
  Serialized Form

### Constructor Summary

Constructors
Constructor and Description
`HibernateJpaDialect()`

### Method Summary

Methods
`Object` `beginTransaction(EntityManager entityManager, TransactionDefinition definition)` This implementation invokes the standard JPA `Transaction.begin` method.
`void` `cleanupTransaction(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)`
`Object` `prepareTransaction(EntityManager entityManager, boolean readOnly, String name)` Prepare a JPA transaction, applying the specified semantics.
`DataAccessException` `translateExceptionIfPossible(RuntimeException ex)` This implementation delegates to EntityManagerFactoryUtils.

### Methods inherited from class org.springframework.orm.jpa.DefaultJpaDialect

`getEntityManagerFactoryPlusOperations, getEntityManagerPlusOperations, releaseJdbcConnection, supportsEntityManagerFactoryPlusOperations, supportsEntityManagerPlusOperations`

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Constructor Detail

#### HibernateJpaDialect

    public HibernateJpaDialect()

### Method Detail

#### beginTransaction

    public Object beginTransaction(EntityManager entityManager,
                          TransactionDefinition definition)
                            throws PersistenceException,
                                   SQLException,
                                   TransactionException

Description copied from class: `DefaultJpaDialect`
This implementation invokes the standard JPA `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.

Specified by:
  `beginTransaction` in interface `JpaDialect`
Overrides:
  `beginTransaction` in class `DefaultJpaDialect`
Parameters:
  `entityManager` - the EntityManager to begin a JPA transaction on
  `definition` - the Spring transaction definition that defines semantics
Returns:
  an arbitrary object that holds transaction data, if any (to be passed into `JpaDialect.cleanupTransaction(java.lang.Object)`). May implement the `SavepointManager` interface.
Throws:
  `PersistenceException` - if thrown by JPA methods
  `SQLException` - if thrown by JDBC methods
  `TransactionException` - in case of invalid arguments
See Also:
  `EntityTransaction.begin()`, `InvalidIsolationLevelException`, `DefaultJpaDialect.cleanupTransaction(java.lang.Object)`

#### prepareTransaction

    public Object prepareTransaction(EntityManager entityManager,
                            boolean readOnly,
                            String name)
                              throws PersistenceException

Description copied from interface: `JpaDialect`
Prepare a JPA transaction, applying the specified semantics. Called by EntityManagerFactoryUtils when enlisting an EntityManager in a JTA transaction.

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).

Specified by:
  `prepareTransaction` in interface `JpaDialect`
Overrides:
  `prepareTransaction` in class `DefaultJpaDialect`
Parameters:
  `entityManager` - the EntityManager to begin a JPA transaction on
  `readOnly` - whether the transaction is supposed to be read-only
  `name` - the name of the transaction (if any)
Returns:
  an arbitrary object that holds transaction data, if any (to be passed into cleanupTransaction)
Throws:
  `PersistenceException` - if thrown by JPA methods
See Also:
  `JpaDialect.cleanupTransaction(java.lang.Object)`

#### cleanupTransaction

    public void cleanupTransaction(Object transactionData)

Description copied from class: `DefaultJpaDialect`
This implementation does nothing, since the default `beginTransaction` implementation does not require any cleanup.

Specified by:
  `cleanupTransaction` in interface `JpaDialect`
Overrides:
  `cleanupTransaction` in class `DefaultJpaDialect`
Parameters:
  `transactionData` - arbitrary object that holds transaction data, if any (as returned by beginTransaction or prepareTransaction)
See Also:
  `DefaultJpaDialect.beginTransaction(javax.persistence.EntityManager, org.springframework.transaction.TransactionDefinition)`

#### getJdbcConnection

    public ConnectionHandle getJdbcConnection(EntityManager entityManager,
                                     boolean readOnly)
                                       throws PersistenceException,
                                              SQLException

Description copied from class: `DefaultJpaDialect`
This implementation always returns `null`, indicating that no JDBC Connection can be provided.

Specified by:
  `getJdbcConnection` in interface `JpaDialect`
Overrides:
  `getJdbcConnection` in class `DefaultJpaDialect`
Parameters:
  `entityManager` - the current JPA EntityManager
  `readOnly` - whether the Connection is only needed for read-only purposes
Returns:
  a handle for the JDBC Connection, to be passed into `releaseJdbcConnection`, or `null` if no JDBC Connection can be retrieved
Throws:
  `PersistenceException` - if thrown by JPA methods
  `SQLException` - if thrown by JDBC methods
See Also:
  `JpaDialect.releaseJdbcConnection(org.springframework.jdbc.datasource.ConnectionHandle, javax.persistence.EntityManager)`, `ConnectionHandle.getConnection()`, `SimpleConnectionHandle`, `JpaTransactionManager.setDataSource(javax.sql.DataSource)`, `NativeJdbcExtractor`

#### translateExceptionIfPossible

    public DataAccessException translateExceptionIfPossible(RuntimeException ex)

Description copied from class: `DefaultJpaDialect`
This implementation delegates to EntityManagerFactoryUtils.

Specified by:
  `translateExceptionIfPossible` in interface `PersistenceExceptionTranslator`
Overrides:
  `translateExceptionIfPossible` in class `DefaultJpaDialect`
Parameters:
  `ex` - a RuntimeException thrown
Returns:
  the corresponding DataAccessException (or `null` if the exception could not be translated, as in this case it may result from user code rather than an actual persistence problem)
See Also:
  `EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(java.lang.RuntimeException)`

#### getSession

    protected Session getSession(EntityManager em)