public interface JpaDialect extends PersistenceExceptionTranslator
Also allows for the provision of value-added methods for portable yet more capable EntityManager and EntityManagerFactory subinterfaces offered by Spring.
In general, it is recommended to derive from DefaultJpaDialect instead of implementing this interface directly. This allows for inheriting common behavior (present and future) from DefaultJpaDialect, only overriding specific hooks to plug in concrete vendor-specific behavior.
DefaultJpaDialect
,
JpaAccessor.setJpaDialect(org.springframework.orm.jpa.JpaDialect)
,
JpaTransactionManager.setJpaDialect(org.springframework.orm.jpa.JpaDialect)
,
JpaVendorAdapter.getJpaDialect()
,
AbstractEntityManagerFactoryBean.setJpaDialect(org.springframework.orm.jpa.JpaDialect)
,
AbstractEntityManagerFactoryBean.setJpaVendorAdapter(org.springframework.orm.jpa.JpaVendorAdapter)
Modifier and Type | Method and Description |
---|---|
java.lang.Object |
beginTransaction(EntityManager entityManager,
TransactionDefinition definition)
Begin the given JPA transaction, applying the semantics specified by the
given Spring transaction definition (in particular, an isolation level
and a timeout).
|
void |
cleanupTransaction(java.lang.Object transactionData)
Clean up the transaction via the given transaction data.
|
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)
Retrieve the JDBC Connection that the given JPA EntityManager uses underneath,
if accessing a relational database.
|
java.lang.Object |
prepareTransaction(EntityManager entityManager,
boolean readOnly,
java.lang.String name)
Prepare a JPA transaction, applying the specified semantics.
|
void |
releaseJdbcConnection(ConnectionHandle conHandle,
EntityManager entityManager)
Release the given JDBC Connection, which has originally been retrieved
via
getJdbcConnection . |
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.
|
translateExceptionIfPossible
boolean supportsEntityManagerFactoryPlusOperations()
boolean supportsEntityManagerPlusOperations()
EntityManagerPlusOperations
,
EntityManagerPlus
EntityManagerFactoryPlusOperations getEntityManagerFactoryPlusOperations(EntityManagerFactory rawEntityManager)
rawEntityManager
- the raw provider-specific EntityManagerFactoryEntityManagerPlusOperations getEntityManagerPlusOperations(EntityManager rawEntityManager)
rawEntityManager
- the raw provider-specific EntityManagerFactoryjava.lang.Object beginTransaction(EntityManager entityManager, TransactionDefinition definition) throws PersistenceException, java.sql.SQLException, TransactionException
An implementation can configure the JPA Transaction object and then
invoke begin
, or invoke a special begin method that takes,
for example, an isolation level.
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
.
It may also apply the read-only flag and isolation level to the underlying
JDBC Connection before beginning the transaction.
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).
This method also allows for exposing savepoint capabilities if supported by
the persistence provider, through returning an Object that implements Spring's
SavepointManager
interface.
JpaTransactionManager
will use this capability if needed.
entityManager
- the EntityManager to begin a JPA transaction ondefinition
- the Spring transaction definition that defines semanticscleanupTransaction(java.lang.Object)
). May implement the
SavepointManager
interface.javax.persistence.PersistenceException
- if thrown by JPA methodsjava.sql.SQLException
- if thrown by JDBC methodsTransactionException
- in case of invalid argumentsPersistenceException
cleanupTransaction(java.lang.Object)
,
javax.persistence.EntityTransaction#begin
,
DataSourceUtils.prepareConnectionForTransaction(java.sql.Connection, org.springframework.transaction.TransactionDefinition)
java.lang.Object prepareTransaction(EntityManager entityManager, boolean readOnly, java.lang.String name) throws PersistenceException
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).
entityManager
- the EntityManager to begin a JPA transaction onreadOnly
- whether the transaction is supposed to be read-onlyname
- the name of the transaction (if any)javax.persistence.PersistenceException
- if thrown by JPA methodsPersistenceException
cleanupTransaction(java.lang.Object)
void cleanupTransaction(java.lang.Object transactionData)
An implementation can, for example, reset read-only flag and isolation level of the underlying JDBC Connection. Furthermore, an exposed data access use case can be reset here.
transactionData
- arbitrary object that holds transaction data, if any
(as returned by beginTransaction or prepareTransaction)beginTransaction(EntityManager, org.springframework.transaction.TransactionDefinition)
,
DataSourceUtils.resetConnectionAfterTransaction(java.sql.Connection, java.lang.Integer)
ConnectionHandle getJdbcConnection(EntityManager entityManager, boolean readOnly) throws PersistenceException, java.sql.SQLException
releaseJdbcConnection
method when not needed anymore.
This strategy is necessary as JPA 1.0 does not provide a standard way to retrieve the underlying JDBC Connection (due to the fact that a JPA implementation might not work with a relational database at all).
Implementations are encouraged to return an unwrapped Connection object, i.e. the Connection as they got it from the connection pool. This makes it easier for application code to get at the underlying native JDBC Connection, like an OracleConnection, which is sometimes necessary for LOB handling etc. We assume that calling code knows how to properly handle the returned Connection object.
In a simple case where the returned Connection will be auto-closed with the
EntityManager or can be released via the Connection object itself, an
implementation can return a SimpleConnectionHandle that just contains the
Connection. If some other object is needed in releaseJdbcConnection
,
an implementation should use a special handle that references that other object.
entityManager
- the current JPA EntityManagerreadOnly
- whether the Connection is only needed for read-only purposesreleaseJdbcConnection
, or null
if no JDBC Connection can be retrievedjavax.persistence.PersistenceException
- if thrown by JPA methodsjava.sql.SQLException
- if thrown by JDBC methodsPersistenceException
releaseJdbcConnection(org.springframework.jdbc.datasource.ConnectionHandle, EntityManager)
,
ConnectionHandle.getConnection()
,
SimpleConnectionHandle
,
JpaTransactionManager.setDataSource(javax.sql.DataSource)
,
NativeJdbcExtractor
void releaseJdbcConnection(ConnectionHandle conHandle, EntityManager entityManager) throws PersistenceException, java.sql.SQLException
getJdbcConnection
. This should be invoked in any case,
to allow for proper release of the retrieved Connection handle.
An implementation might simply do nothing, if the Connection returned
by getJdbcConnection
will be implicitly closed when the JPA
transaction completes or when the EntityManager is closed.
conHandle
- the JDBC Connection handle to releaseentityManager
- the current JPA EntityManagerjavax.persistence.PersistenceException
- if thrown by JPA methodsjava.sql.SQLException
- if thrown by JDBC methodsPersistenceException
getJdbcConnection(EntityManager, boolean)