## org.springframework.orm.jpa
Class DefaultJpaDialect

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

All Implemented Interfaces:
  Serializable, PersistenceExceptionTranslator, JpaDialect

Direct Known Subclasses:
  EclipseLinkJpaDialect, HibernateJpaDialect, OpenJpaDialect, TopLinkJpaDialect

    public class DefaultJpaDialect

extends Object
implements JpaDialect, Serializable

Default implementation of the `JpaDialect` interface. Used as default dialect by `JpaAccessor` and `JpaTransactionManager`.

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

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

Constructor Summary
`DefaultJpaDialect()`

Method Summary
`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.
`EntityManagerFactoryPlusOperations` `getEntityManagerFactoryPlusOperations(EntityManagerFactory rawEntityManager)` Return an EntityManagerFactoryPlusOperations implementation for the given raw EntityManagerFactory.
`EntityManagerPlusOperations` `getEntityManagerPlusOperations(EntityManager rawEntityManager)` Return an EntityManagerPlusOperations implementation for the given raw EntityManager.
`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)` Prepare a JPA transaction, applying the specified semantics.
`void` `releaseJdbcConnection(ConnectionHandle conHandle, EntityManager em)` This implementation does nothing, assuming that the Connection will implicitly be closed with the EntityManager.
`boolean` `supportsEntityManagerFactoryPlusOperations()` Return whether the EntityManagerFactoryPlus(Operations) interface is supported by this provider.
`boolean` `supportsEntityManagerPlusOperations()` Return whether the EntityManagerPlus(Operations) interface is supported by this provider.
`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 Detail

### DefaultJpaDialect

    public DefaultJpaDialect()

Method Detail

### beginTransaction

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

  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(javax.persistence.EntityManager, org.springframework.transaction.TransactionDefinition)`

### getJdbcConnection

    public 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 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`

### releaseJdbcConnection

    public void releaseJdbcConnection(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

    public DataAccessException translateExceptionIfPossible(RuntimeException ex)

  This implementation delegates to EntityManagerFactoryUtils.

  Specified by:
    `translateExceptionIfPossible` in interface `PersistenceExceptionTranslator`
  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)`

### supportsEntityManagerFactoryPlusOperations

    public boolean supportsEntityManagerFactoryPlusOperations()

  Description copied from interface: `JpaDialect`
  Return whether the EntityManagerFactoryPlus(Operations) interface is supported by this provider.

  Specified by:
    `supportsEntityManagerFactoryPlusOperations` in interface `JpaDialect`
  See Also:
    `EntityManagerFactoryPlusOperations`, `EntityManagerFactoryPlus`

### supportsEntityManagerPlusOperations

    public boolean supportsEntityManagerPlusOperations()

  Description copied from interface: `JpaDialect`
  Return whether the EntityManagerPlus(Operations) interface is supported by this provider.

  Specified by:
    `supportsEntityManagerPlusOperations` in interface `JpaDialect`
  See Also:
    `EntityManagerPlusOperations`, `EntityManagerPlus`

### getEntityManagerFactoryPlusOperations

    public EntityManagerFactoryPlusOperations getEntityManagerFactoryPlusOperations(EntityManagerFactory rawEntityManager)

  Description copied from interface: `JpaDialect`
  Return an EntityManagerFactoryPlusOperations implementation for the given raw EntityManagerFactory. This operations object can be used to serve the additional operations behind a proxy that implements the EntityManagerFactoryPlus interface.

  Specified by:
    `getEntityManagerFactoryPlusOperations` in interface `JpaDialect`
  Parameters:
    `rawEntityManager` - the raw provider-specific EntityManagerFactory
  Returns:
    the EntityManagerFactoryPlusOperations implementation

### getEntityManagerPlusOperations

    public EntityManagerPlusOperations getEntityManagerPlusOperations(EntityManager rawEntityManager)

  Description copied from interface: `JpaDialect`
  Return an EntityManagerPlusOperations implementation for the given raw EntityManager. This operations object can be used to serve the additional operations behind a proxy that implements the EntityManagerPlus interface.

  Specified by:
    `getEntityManagerPlusOperations` in interface `JpaDialect`
  Parameters:
    `rawEntityManager` - the raw provider-specific EntityManagerFactory
  Returns:
    the EntityManagerFactoryPlusOperations implementation