|
The Spring Framework | |||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Objectorg.springframework.orm.jdo.DefaultJdoDialect
public class DefaultJdoDialect
Default implementation of the JdoDialect interface. Updated to leverage the JDO 2.0 API when available, as of Spring 1.2. Used as default dialect by JdoAccessor and JdoTransactionManager.
Simply begins a standard JDO transaction in beginTransaction
.
Returns a handle for a JDO2 DataStoreConnection on getJdbcConnection
.
Calls the corresponding JDO2 operations on detachCopy(All)
,
attachCopy(All)
, flush
and newNamedQuery
.
Ignores a given query timeout in applyQueryTimeout
.
Uses a Spring SQLExceptionTranslator for exception translation, if applicable.
Note that, even with JDO2, vendor-specific subclasses are still necessary
for special transaction semantics and more sophisticated exception translation.
Furthermore, vendor-specific subclasses are encouraged to expose the native JDBC
Connection on getJdbcConnection
, rather than JDO2's wrapper handle.
This class also implements the PersistenceExceptionTranslator interface, as autodetected by Spring's PersistenceExceptionTranslationPostProcessor, for AOP-based translation of native exceptions to Spring DataAccessExceptions. Hence, the presence of a standard DefaultJdoDialect bean automatically enables a PersistenceExceptionTranslationPostProcessor to translate JDO exceptions.
setJdbcExceptionTranslator(org.springframework.jdbc.support.SQLExceptionTranslator)
,
JdoAccessor.setJdoDialect(org.springframework.orm.jdo.JdoDialect)
,
JdoTransactionManager.setJdoDialect(org.springframework.orm.jdo.JdoDialect)
,
PersistenceExceptionTranslationPostProcessor
Field Summary | |
---|---|
protected Log |
logger
|
Constructor Summary | |
---|---|
DefaultJdoDialect()
Create a new DefaultJdoDialect. |
|
DefaultJdoDialect(Object connectionFactory)
Create a new DefaultJdoDialect. |
Method Summary | |
---|---|
void |
applyQueryTimeout(javax.jdo.Query query,
int remainingTimeInSeconds)
This implementation logs a warning that it cannot apply a query timeout. |
Object |
attachCopy(javax.jdo.PersistenceManager pm,
Object detachedEntity)
This implementation delegates to JDO 2.0's makePersistent method,
which also serves as facility for reattaching objects as of JDO 2.0 final draft. |
Collection |
attachCopyAll(javax.jdo.PersistenceManager pm,
Collection detachedEntities)
This implementation delegates to JDO 2.0's makePersistentAll method,
which also serves as facility for reattaching objects as of JDO 2.0 final draft. |
Object |
beginTransaction(javax.jdo.Transaction transaction,
TransactionDefinition definition)
This implementation invokes the standard JDO Transaction.begin
method. |
void |
cleanupTransaction(Object transactionData)
This implementation does nothing, as the default beginTransaction implementation does not require any cleanup. |
Object |
detachCopy(javax.jdo.PersistenceManager pm,
Object entity)
This implementation delegates to JDO 2.0's detachCopy method. |
Collection |
detachCopyAll(javax.jdo.PersistenceManager pm,
Collection entities)
This implementation delegates to JDO 2.0's detachCopyAll method. |
protected String |
extractSqlStringFromException(javax.jdo.JDOException ex)
Template method for extracting a SQL String from the given exception. |
void |
flush(javax.jdo.PersistenceManager pm)
This implementation delegates to JDO 2.0's flush method. |
ConnectionHandle |
getJdbcConnection(javax.jdo.PersistenceManager pm,
boolean readOnly)
This implementation returns a DataStoreConnectionHandle for JDO2, which will also work on JDO1 until actually accessing the JDBC Connection. |
SQLExceptionTranslator |
getJdbcExceptionTranslator()
Return the JDBC exception translator for this dialect, if any. |
javax.jdo.Query |
newNamedQuery(javax.jdo.PersistenceManager pm,
Class entityClass,
String queryName)
This implementation delegates to JDO 2.0's newNamedQuery method. |
void |
releaseJdbcConnection(ConnectionHandle conHandle,
javax.jdo.PersistenceManager pm)
This implementation does nothing, assuming that the Connection will implicitly be closed with the PersistenceManager. |
void |
setJdbcExceptionTranslator(SQLExceptionTranslator jdbcExceptionTranslator)
Set the JDBC exception translator for this dialect. |
DataAccessException |
translateException(javax.jdo.JDOException ex)
This implementation delegates to PersistenceManagerFactoryUtils. |
DataAccessException |
translateExceptionIfPossible(RuntimeException ex)
Implementation of the PersistenceExceptionTranslator interface, as autodetected by Spring's PersistenceExceptionTranslationPostProcessor. |
Methods inherited from class java.lang.Object |
---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
Field Detail |
---|
protected final Log logger
Constructor Detail |
---|
public DefaultJdoDialect()
DefaultJdoDialect(Object connectionFactory)
connectionFactory
- the connection factory of the JDO PersistenceManagerFactory,
which is used to initialize the default JDBC exception translatorPersistenceManagerFactory.getConnectionFactory()
,
PersistenceManagerFactoryUtils.newJdbcExceptionTranslator(Object)
Method Detail |
---|
public void setJdbcExceptionTranslator(SQLExceptionTranslator jdbcExceptionTranslator)
Applied to any SQLException root cause of a JDOException, if specified. The default is to rely on the JDO provider's native exception translation.
jdbcExceptionTranslator
- exception translatorSQLException
,
JDOException.getCause()
,
SQLErrorCodeSQLExceptionTranslator
,
SQLStateSQLExceptionTranslator
public SQLExceptionTranslator getJdbcExceptionTranslator()
public Object beginTransaction(javax.jdo.Transaction transaction, TransactionDefinition definition) throws javax.jdo.JDOException, SQLException, TransactionException
Transaction.begin
method. Throws an InvalidIsolationLevelException if a non-default isolation
level is set.
beginTransaction
in interface JdoDialect
transaction
- the JDO transaction to begindefinition
- the Spring transaction definition that defines semantics
javax.jdo.JDOException
- if thrown by JDO methods
SQLException
- if thrown by JDBC methods
TransactionException
- in case of invalid argumentsTransaction.begin()
,
InvalidIsolationLevelException
public void cleanupTransaction(Object transactionData)
cleanupTransaction
in interface JdoDialect
transactionData
- arbitrary object that holds transaction data, if any
(as returned by beginTransaction)beginTransaction(javax.jdo.Transaction, org.springframework.transaction.TransactionDefinition)
public ConnectionHandle getJdbcConnection(javax.jdo.PersistenceManager pm, boolean readOnly) throws javax.jdo.JDOException, SQLException
For pre-JDO2 implementations, override this method to return the
Connection through the corresponding vendor-specific mechanism, or null
if the Connection is not retrievable.
NOTE: A JDO2 DataStoreConnection is always a wrapper, never the native JDBC Connection. If you need access to the native JDBC Connection (or the connection pool handle, to be unwrapped via a Spring NativeJdbcExtractor), override this method to return the native Connection through the corresponding vendor-specific mechanism.
A JDO2 DataStoreConnection is only "borrowed" from the PersistenceManager:
it needs to be returned as early as possible. Effectively, JDO2 requires the
fetched Connection to be closed before continuing PersistenceManager work.
For this reason, the exposed ConnectionHandle eagerly releases its JDBC
Connection at the end of each JDBC data access operation (that is, on
DataSourceUtils.releaseConnection
).
getJdbcConnection
in interface JdoDialect
pm
- the current JDO PersistenceManager
releaseJdbcConnection
, or null
if no JDBC Connection can be retrieved
javax.jdo.JDOException
- if thrown by JDO methods
SQLException
- if thrown by JDBC methodsPersistenceManager.getDataStoreConnection()
,
NativeJdbcExtractor
,
DataSourceUtils.releaseConnection(java.sql.Connection, javax.sql.DataSource)
public void releaseJdbcConnection(ConnectionHandle conHandle, javax.jdo.PersistenceManager pm) throws javax.jdo.JDOException, SQLException
If the JDO provider returns a Connection handle that it
expects the application to close, the dialect needs to invoke
Connection.close
here.
releaseJdbcConnection
in interface JdoDialect
conHandle
- the JDBC Connection handle to releasepm
- the current JDO PersistenceManager
javax.jdo.JDOException
- if thrown by JDO methods
SQLException
- if thrown by JDBC methodsConnection.close()
public Object detachCopy(javax.jdo.PersistenceManager pm, Object entity) throws javax.jdo.JDOException
detachCopy
method.
To be overridden for pre-JDO2 implementations, using the corresponding vendor-specific mechanism there.
detachCopy
in interface JdoDialect
pm
- the current JDO PersistenceManagerentity
- the persistent instance to detach
javax.jdo.JDOException
- in case of errorsPersistenceManager.detachCopy(Object)
public Collection detachCopyAll(javax.jdo.PersistenceManager pm, Collection entities) throws javax.jdo.JDOException
detachCopyAll
method.
To be overridden for pre-JDO2 implementations, using the corresponding vendor-specific mechanism there.
detachCopyAll
in interface JdoDialect
pm
- the current JDO PersistenceManagerentities
- the persistent instances to detach
javax.jdo.JDOException
- in case of errorsPersistenceManager.detachCopyAll(java.util.Collection)
public Object attachCopy(javax.jdo.PersistenceManager pm, Object detachedEntity) throws javax.jdo.JDOException
makePersistent
method,
which also serves as facility for reattaching objects as of JDO 2.0 final draft.
To be overridden for pre-JDO2 implementations, using the corresponding vendor-specific mechanism there.
Note that previous JDO 2.0 drafts specified a dedicated attachCopy
method for this purpose, which Spring's DefaultJdoDialect used to delegate to.
As of Spring 2.0, this has been adapted to the final JDO 2.0 API. You can still
create a custom JdoDialect that uses the pre-final API methods, of course.
attachCopy
in interface JdoDialect
pm
- the current JDO PersistenceManagerdetachedEntity
- the detached instance to attach
javax.jdo.JDOException
- in case of errorsPersistenceManager.makePersistent(Object)
public Collection attachCopyAll(javax.jdo.PersistenceManager pm, Collection detachedEntities) throws javax.jdo.JDOException
makePersistentAll
method,
which also serves as facility for reattaching objects as of JDO 2.0 final draft.
To be overridden for pre-JDO2 implementations, using the corresponding vendor-specific mechanism there.
Note that previous JDO 2.0 drafts specified a dedicated attachCopy
method for this purpose, which Spring's DefaultJdoDialect used to delegate to.
As of Spring 2.0, this has been adapted to the final JDO 2.0 API. You can still
create a custom JdoDialect that uses the pre-final API methods, of course.
attachCopyAll
in interface JdoDialect
pm
- the current JDO PersistenceManagerdetachedEntities
- the detached instances to reattach
javax.jdo.JDOException
- in case of errorsPersistenceManager.makePersistentAll(java.util.Collection)
public void flush(javax.jdo.PersistenceManager pm) throws javax.jdo.JDOException
flush
method.
To be overridden for pre-JDO2 implementations, using the corresponding vendor-specific mechanism there.
flush
in interface JdoDialect
pm
- the current JDO PersistenceManager
javax.jdo.JDOException
- in case of errorsPersistenceManager.flush()
public javax.jdo.Query newNamedQuery(javax.jdo.PersistenceManager pm, Class entityClass, String queryName) throws javax.jdo.JDOException
newNamedQuery
method.
To be overridden for pre-JDO2 implementations, using the corresponding vendor-specific mechanism there.
newNamedQuery
in interface JdoDialect
pm
- the current JDO PersistenceManagerentityClass
- a persistent classqueryName
- the name of the query
javax.jdo.JDOException
- in case of errorsPersistenceManager.newNamedQuery(Class, String)
public void applyQueryTimeout(javax.jdo.Query query, int remainingTimeInSeconds) throws javax.jdo.JDOException
applyQueryTimeout
in interface JdoDialect
query
- the JDO query object to apply the timeout toremainingTimeInSeconds
- the timeout value to apply
javax.jdo.JDOException
- if thrown by JDO methodsJdoTemplate.prepareQuery(javax.jdo.Query)
public DataAccessException translateExceptionIfPossible(RuntimeException ex)
Converts the exception if it is a JDOException, using this JdoDialect.
Else returns null
to indicate an unknown exception.
translateExceptionIfPossible
in interface PersistenceExceptionTranslator
ex
- a RuntimeException thrown
null
if the
exception could not be translated, as in this case it may result from
user code rather than an actual persistence problem)PersistenceExceptionTranslationPostProcessor
,
translateException(javax.jdo.JDOException)
public DataAccessException translateException(javax.jdo.JDOException ex)
translateException
in interface JdoDialect
ex
- the JDOException thrown
null
)PersistenceManagerFactoryUtils.convertJdoAccessException(javax.jdo.JDOException)
protected String extractSqlStringFromException(javax.jdo.JDOException ex)
Default implementation always returns null
. Can be overridden in
subclasses to extract SQL Strings for vendor-specific exception classes.
ex
- the JDOException, containing a SQLException
null
if none found
|
The Spring Framework | |||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |