Package org.springframework.orm.jpa

# Class DefaultJpaDialect

java.lang.Object
org.springframework.orm.jpa.DefaultJpaDialect

All Implemented Interfaces:
  `Serializable`, `org.springframework.dao.support.PersistenceExceptionTranslator`, `JpaDialect`

Direct Known Subclasses:
  `EclipseLinkJpaDialect`, `HibernateJpaDialect`

public class DefaultJpaDialect extends Object implements JpaDialect, Serializable
Default implementation of the `JpaDialect` interface. Used as default dialect by `JpaTransactionManager`.

Simply begins a standard JPA transaction in `beginTransaction(jakarta.persistence.EntityManager, org.springframework.transaction.TransactionDefinition)` and performs standard exception translation through `EntityManagerFactoryUtils`.

Since:
  2.0
Author:
  Juergen Hoeller
See Also:
  - `JpaTransactionManager.setJpaDialect(org.springframework.orm.jpa.JpaDialect)`
  - Serialized Form

## Constructor Summary

Constructors
Constructor
Description
`DefaultJpaDialect()`

## 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.
`org.springframework.jdbc.datasource.ConnectionHandle`
`getJdbcConnection(EntityManager entityManager, boolean readOnly)`
This implementation always returns `null`, indicating that no JDBC Connection can be provided.
`Object`
`prepareTransaction(EntityManager entityManager, boolean readOnly, String name)`
This implementation simply returns `null` for no transaction data.
`void`
`releaseJdbcConnection(org.springframework.jdbc.datasource.ConnectionHandle conHandle, EntityManager em)`
This implementation does nothing, assuming that the Connection will implicitly be closed with the EntityManager.
`org.springframework.dao.DataAccessException`
`translateExceptionIfPossible(RuntimeException ex)`
This implementation delegates to EntityManagerFactoryUtils.

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

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

## Constructor Details

### DefaultJpaDialect

public DefaultJpaDialect()

## Method Details

### beginTransaction

@Nullable public Object beginTransaction(EntityManager entityManager, org.springframework.transaction.TransactionDefinition definition) throws PersistenceException, SQLException, org.springframework.transaction.TransactionException
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`
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`
  - `cleanupTransaction(java.lang.Object)`

### prepareTransaction

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

Specified by:
  `prepareTransaction` in interface `JpaDialect`
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)`

### cleanupTransaction

public void cleanupTransaction(@Nullable Object transactionData)
This implementation does nothing, since the default `beginTransaction` implementation does not require any cleanup.

Specified by:
  `cleanupTransaction` in interface `JpaDialect`
Parameters:
  `transactionData` - arbitrary object that holds transaction data, if any (as returned by beginTransaction or prepareTransaction)
See Also:
  - `beginTransaction(jakarta.persistence.EntityManager, org.springframework.transaction.TransactionDefinition)`
  - `prepareTransaction(jakarta.persistence.EntityManager, boolean, java.lang.String)`

### getJdbcConnection

@Nullable public org.springframework.jdbc.datasource.ConnectionHandle getJdbcConnection(EntityManager entityManager, boolean readOnly) throws PersistenceException, SQLException
This implementation always returns `null`, indicating that no JDBC Connection can be provided.

Specified by:
  `getJdbcConnection` in interface `JpaDialect`
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)`

### releaseJdbcConnection

public void releaseJdbcConnection(org.springframework.jdbc.datasource.ConnectionHandle conHandle, EntityManager em) throws PersistenceException, SQLException
This implementation does nothing, assuming that the Connection will implicitly be closed with the EntityManager.

If the JPA implementation returns a Connection handle that it expects the application to close after use, the dialect implementation needs to invoke `Connection.close()` (or some other method with similar effect) here.

Specified by:
  `releaseJdbcConnection` in interface `JpaDialect`
Parameters:
  `conHandle` - the JDBC Connection handle to release
  `em` - the current JPA EntityManager
Throws:
  `PersistenceException` - if thrown by JPA methods
  `SQLException` - if thrown by JDBC methods
See Also:
  - `Connection.close()`

### translateExceptionIfPossible

@Nullable public org.springframework.dao.DataAccessException translateExceptionIfPossible(RuntimeException ex)
This implementation delegates to EntityManagerFactoryUtils.

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