public interface JdoDialect
JDO 2.0 defines standard ways for most of the functionality covered here.
Hence, Spring's DefaultJdoDialect
uses the corresponding JDO 2.0 methods
by default, to be overridden in a vendor-specific fashion if necessary.
Vendor-specific subclasses of DefaultJdoDialect
are still required for special
transaction semantics and more sophisticated exception translation (if needed).
In general, it is recommended to derive from DefaultJdoDialect
instead
of implementing this interface directly. This allows for inheriting common
behavior (present and future) from DefaultJdoDialect
, only overriding
specific hooks to plug in concrete vendor-specific behavior.
JdoTransactionManager.setJdoDialect(org.springframework.orm.jdo.JdoDialect)
,
JdoAccessor.setJdoDialect(org.springframework.orm.jdo.JdoDialect)
,
DefaultJdoDialect
Modifier and Type | Method and Description |
---|---|
void |
applyQueryTimeout(javax.jdo.Query query,
int timeout)
Apply the given timeout to the given JDO query object.
|
Object |
beginTransaction(javax.jdo.Transaction transaction,
TransactionDefinition definition)
Begin the given JDO transaction, applying the semantics specified by the
given Spring transaction definition (in particular, an isolation level
and a timeout).
|
void |
cleanupTransaction(Object transactionData)
Clean up the transaction via the given transaction data.
|
ConnectionHandle |
getJdbcConnection(javax.jdo.PersistenceManager pm,
boolean readOnly)
Retrieve the JDBC Connection that the given JDO PersistenceManager uses underneath,
if accessing a relational database.
|
void |
releaseJdbcConnection(ConnectionHandle conHandle,
javax.jdo.PersistenceManager pm)
Release the given JDBC Connection, which has originally been retrieved
via
getJdbcConnection . |
DataAccessException |
translateException(javax.jdo.JDOException ex)
Translate the given JDOException to a corresponding exception from Spring's
generic DataAccessException hierarchy.
|
Object beginTransaction(javax.jdo.Transaction transaction, TransactionDefinition definition) throws javax.jdo.JDOException, SQLException, TransactionException
An implementation can configure the JDO Transaction object and then
invoke begin
, or invoke a special begin method that takes,
for example, an isolation level.
An implementation can also apply read-only flag and isolation level to the
underlying JDBC Connection before beginning the transaction. In that case,
a transaction data object can be returned that holds the previous isolation
level (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).
transaction
- the JDO transaction to begindefinition
- the Spring transaction definition that defines semanticsjavax.jdo.JDOException
- if thrown by JDO methodsSQLException
- if thrown by JDBC methodsTransactionException
- in case of invalid argumentscleanupTransaction(java.lang.Object)
,
Transaction.begin()
,
DataSourceUtils.prepareConnectionForTransaction(java.sql.Connection, org.springframework.transaction.TransactionDefinition)
void cleanupTransaction(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)beginTransaction(javax.jdo.Transaction, org.springframework.transaction.TransactionDefinition)
,
DataSourceUtils.resetConnectionAfterTransaction(java.sql.Connection, java.lang.Integer)
ConnectionHandle getJdbcConnection(javax.jdo.PersistenceManager pm, boolean readOnly) throws javax.jdo.JDOException, SQLException
releaseJdbcConnection
method when not needed anymore.
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
PersistenceManager 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.
pm
- the current JDO PersistenceManagerreadOnly
- whether the Connection is only needed for read-only purposesreleaseJdbcConnection
, or null
if no JDBC Connection can be retrievedjavax.jdo.JDOException
- if thrown by JDO methodsSQLException
- if thrown by JDBC methodsreleaseJdbcConnection(org.springframework.jdbc.datasource.ConnectionHandle, javax.jdo.PersistenceManager)
,
ConnectionHandle.getConnection()
,
SimpleConnectionHandle
,
JdoTransactionManager.setDataSource(javax.sql.DataSource)
,
NativeJdbcExtractor
void releaseJdbcConnection(ConnectionHandle conHandle, javax.jdo.PersistenceManager pm) throws javax.jdo.JDOException, 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 JDO
transaction completes or when the PersistenceManager is closed.
conHandle
- the JDBC Connection handle to releasepm
- the current JDO PersistenceManagerjavax.jdo.JDOException
- if thrown by JDO methodsSQLException
- if thrown by JDBC methodsgetJdbcConnection(javax.jdo.PersistenceManager, boolean)
void applyQueryTimeout(javax.jdo.Query query, int timeout) throws javax.jdo.JDOException
Invoked with the remaining time of a specified transaction timeout, if any.
query
- the JDO query object to apply the timeout totimeout
- the timeout value (seconds) to applyjavax.jdo.JDOException
- if thrown by JDO methodsJdoTemplate.prepareQuery(javax.jdo.Query)
DataAccessException translateException(javax.jdo.JDOException ex)
Of particular importance is the correct translation to DataIntegrityViolationException, for example on constraint violation. Unfortunately, standard JDO does not allow for portable detection of this.
Can use a SQLExceptionTranslator for translating underlying SQLExceptions in a database-specific fashion.
ex
- the JDOException thrownnull
)JdoAccessor.convertJdoAccessException(javax.jdo.JDOException)
,
JdoTransactionManager.convertJdoAccessException(javax.jdo.JDOException)
,
PersistenceManagerFactoryUtils.convertJdoAccessException(javax.jdo.JDOException)
,
DataIntegrityViolationException
,
SQLExceptionTranslator