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

    Constructors
    Constructor and Description
    `DefaultJpaDialect()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `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