org.springframework.orm.jpa.vendor

## Class OpenJpaDialect

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

- All Implemented Interfaces:
    Serializable, PersistenceExceptionTranslator, JpaDialect

      public class OpenJpaDialect
      extends DefaultJpaDialect

  `JpaDialect` implementation for Apache OpenJPA. Developed and tested against OpenJPA 2.2.
  Since:
    2.0
  Author:
    Costin Leau, Juergen Hoeller
  See Also:
    Serialized Form

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `OpenJpaDialect()`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `Object` | `beginTransaction(EntityManager entityManager, TransactionDefinition definition)` This implementation invokes the standard JPA `Transaction.begin` method.
    `ConnectionHandle` | `getJdbcConnection(EntityManager entityManager, boolean readOnly)` This implementation always returns `null`, indicating that no JDBC Connection can be provided.
    `protected org.apache.openjpa.persistence.OpenJPAEntityManager` | `getOpenJPAEntityManager(EntityManager em)` Return the OpenJPA-specific variant of `EntityManager`.

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

      `cleanupTransaction, prepareTransaction, releaseJdbcConnection, translateExceptionIfPossible`

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

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

- - ### Constructor Detail

    - #### OpenJpaDialect

          public OpenJpaDialect()

  - ### 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)`

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

    - #### getOpenJPAEntityManager

          protected org.apache.openjpa.persistence.OpenJPAEntityManager getOpenJPAEntityManager(EntityManager em)

      Return the OpenJPA-specific variant of `EntityManager`.
      Parameters:
        `em` - the generic `EntityManager` instance
      Returns:
        the OpenJPA-specific variant of `EntityManager`