Package 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`, `org.springframework.dao.support.PersistenceExceptionTranslator`, `JpaDialect`

public class HibernateJpaDialect extends DefaultJpaDialect
`JpaDialect` implementation for Hibernate. Compatible with Hibernate ORM 5.5/5.6 as well as 6.x.

Since:
  2.0
Author:
  Juergen Hoeller, Costin Leau
See Also:
  - `HibernateJpaVendorAdapter`
  - `Session.setHibernateFlushMode(org.hibernate.FlushMode)`
  - `Transaction.setTimeout(int)`
  - Serialized Form

## Constructor Summary

Constructors
Constructor
Description
`HibernateJpaDialect()`

## Method Summary

Modifier and Type
Method
Description
`Object`
`beginTransaction(EntityManager entityManager, org.springframework.transaction.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.
`protected org.springframework.dao.DataAccessException`
`convertHibernateAccessException(HibernateException ex)`
Convert the given HibernateException to an appropriate exception from the `org.springframework.dao` hierarchy.
`protected Object`
`getIdentifier(HibernateException hibEx)`
`org.springframework.jdbc.datasource.ConnectionHandle`
`getJdbcConnection(EntityManager entityManager, boolean readOnly)`
This implementation always returns `null`, indicating that no JDBC Connection can be provided.
`protected SessionImplementor`
`getSession(EntityManager entityManager)`
`protected FlushMode`
`prepareFlushMode(Session session, boolean readOnly)`
`Object`
`prepareTransaction(EntityManager entityManager, boolean readOnly, String name)`
This implementation simply returns `null` for no transaction data.
`void`
`setJdbcExceptionTranslator(org.springframework.jdbc.support.SQLExceptionTranslator exceptionTranslator)`
Set the JDBC exception translator for Hibernate exception translation purposes.
`void`
`setPrepareConnection(boolean prepareConnection)`
Set whether to prepare the underlying JDBC Connection of a transactional Hibernate Session, that is, whether to apply a transaction-specific isolation level and/or the transaction's read-only flag to the underlying JDBC Connection.
`org.springframework.dao.DataAccessException`
`translateExceptionIfPossible(RuntimeException ex)`
This implementation delegates to EntityManagerFactoryUtils.

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

`releaseJdbcConnection`

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

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

## Constructor Details

### HibernateJpaDialect

public HibernateJpaDialect()

## Method Details

### setPrepareConnection

public void setPrepareConnection(boolean prepareConnection)
Set whether to prepare the underlying JDBC Connection of a transactional Hibernate Session, that is, whether to apply a transaction-specific isolation level and/or the transaction's read-only flag to the underlying JDBC Connection.

Default is "true". If you turn this flag off, JPA transaction management will not support per-transaction isolation levels anymore. It will not call `Connection.setReadOnly(true)` for read-only transactions anymore either. If this flag is turned off, no cleanup of a JDBC Connection is required after a transaction, since no Connection settings will get modified.

NOTE: The default behavior in terms of read-only handling changed in Spring 4.1, propagating the read-only status to the JDBC Connection now, analogous to other Spring transaction managers. This may have the effect that you're running into read-only enforcement now where previously write access has accidentally been tolerated: Please revise your transaction declarations accordingly, removing invalid read-only markers if necessary.

Since:
  4.1
See Also:
  - `Connection.setTransactionIsolation(int)`
  - `Connection.setReadOnly(boolean)`

### setJdbcExceptionTranslator

public void setJdbcExceptionTranslator(@Nullable org.springframework.jdbc.support.SQLExceptionTranslator exceptionTranslator)
Set the JDBC exception translator for Hibernate exception translation purposes.

Applied to any detected `SQLException` root cause of a Hibernate `JDBCException`, overriding Hibernate's own `SQLException` translation (which is based on a Hibernate Dialect for a specific target database).

As of 6.1, also applied to `TransactionException` translation with a `SQLException` root cause (where Hibernate does not translate itself at all), overriding Spring's default `SQLExceptionSubclassTranslator` there.

Parameters:
  `exceptionTranslator` - the `SQLExceptionTranslator` to delegate to, or `null` for none. By default, a `SQLExceptionSubclassTranslator` will be used for `TransactionException` translation as of 6.1; this can be reverted to pre-6.1 behavior through setting `null` here.
Since:
  5.1
See Also:
  - `SQLException`
  - `JDBCException`
  - `SQLExceptionSubclassTranslator`
  - `SQLErrorCodeSQLExceptionTranslator`

### beginTransaction

public Object beginTransaction(EntityManager entityManager, org.springframework.transaction.TransactionDefinition definition) throws PersistenceException, SQLException, org.springframework.transaction.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
  `org.springframework.transaction.TransactionException` - in case of invalid arguments
See Also:
  - `EntityTransaction.begin()`
  - `InvalidIsolationLevelException`
  - `DefaultJpaDialect.cleanupTransaction(java.lang.Object)`

### prepareTransaction

public Object prepareTransaction(EntityManager entityManager, boolean readOnly, @Nullable String name) throws PersistenceException
Description copied from class: `DefaultJpaDialect`
This implementation simply returns `null` for no transaction data.

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 `JpaDialect.cleanupTransaction(java.lang.Object)`)
Throws:
  `PersistenceException` - if thrown by JPA methods
See Also:
  - `JpaDialect.cleanupTransaction(java.lang.Object)`

### prepareFlushMode

@Nullable protected FlushMode prepareFlushMode(Session session, boolean readOnly) throws PersistenceException

Throws:
  `PersistenceException`

### cleanupTransaction

public void cleanupTransaction(@Nullable 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(jakarta.persistence.EntityManager, org.springframework.transaction.TransactionDefinition)`
  - `DefaultJpaDialect.prepareTransaction(jakarta.persistence.EntityManager, boolean, java.lang.String)`

### getJdbcConnection

public org.springframework.jdbc.datasource.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 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, jakarta.persistence.EntityManager)`
  - `ConnectionHandle.getConnection()`
  - `SimpleConnectionHandle`
  - `JpaTransactionManager.setDataSource(javax.sql.DataSource)`

### translateExceptionIfPossible

@Nullable public org.springframework.dao.DataAccessException translateExceptionIfPossible(RuntimeException ex)
Description copied from class: `DefaultJpaDialect`
This implementation delegates to EntityManagerFactoryUtils.

Specified by:
  `translateExceptionIfPossible` in interface `org.springframework.dao.support.PersistenceExceptionTranslator`
Overrides:
  `translateExceptionIfPossible` in class `DefaultJpaDialect`
See Also:
  - `EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(java.lang.RuntimeException)`

### convertHibernateAccessException

protected org.springframework.dao.DataAccessException convertHibernateAccessException(HibernateException ex)
Convert the given HibernateException to an appropriate exception from the `org.springframework.dao` hierarchy.

Parameters:
  `ex` - the HibernateException that occurred
Returns:
  the corresponding DataAccessException instance

### getSession

protected SessionImplementor getSession(EntityManager entityManager)

### getIdentifier

@Nullable protected Object getIdentifier(HibernateException hibEx)