| org.springframework.jdbc.support.nativejdbc.NativeJdbcExtractor
All known Subclasses: org.springframework.jdbc.support.nativejdbc.NativeJdbcExtractorAdapter,
| NativeJdbcExtractor | | public interface NativeJdbcExtractor (Code) | | Interface for extracting native JDBC objects from wrapped objects coming from
connection pools. This is necessary to be able to case to native implementations
like OracleConnection or OracleResultSet in application code, for example to
create Blobs or access other vendor-specific features.
Note: Setting a custom NativeJdbcExtractor is just necessary if you want to
cast to database-specific implementations, like OracleConnection/OracleResultSet.
Else, any wrapped JDBC object will be fine.
Note: To be able to support any pool's strategy of native ResultSet wrapping,
it is advisable to get both the native Statement and the native ResultSet
via this extractor. Some pools just allow to unwrap the Statement, some just to
unwrap the ResultSet - the above strategy will cover both. It is typically
not necessary to unwrap the Connection to retrieve a native ResultSet.
When working with a simple connection pool that wraps Connections but not
Statements, a SimpleNativeJdbcExtractor is often sufficient. However, some
pools (like Jakarta's Commons DBCP) wrap all JDBC objects that they
return: Therefore, you need to use a specific NativeJdbcExtractor (like
CommonsDbcpNativeJdbcExtractor) with them.
JdbcTemplate can properly apply a NativeJdbcExtractor if specified, correctly
unwrapping all JDBC objects that it creates. Note that this is just necessary
if you want to cast to native implementations in your data access code.
The Oracle-specific implementation of Spring's LobHandler interface needs
a NativeJdbcExtractor to be able to work on the native OracleConnection.
This is also necessary for other Oracle-specific features that you may want
to leverage in your applications, such as InterMedia.
author:
Juergen Hoeller
since:
25.08.2003
See Also: SimpleNativeJdbcExtractor
See Also: CommonsDbcpNativeJdbcExtractor
See Also: org.springframework.jdbc.core.JdbcTemplate.setNativeJdbcExtractor
See Also: org.springframework.jdbc.support.lob.OracleLobHandler.setNativeJdbcExtractor |
| getNativeCallableStatement | | CallableStatement getNativeCallableStatement(CallableStatement cs) throws SQLException(Code) | | Retrieve the underlying native JDBC CallableStatement for the given statement.
Supposed to return the given CallableStatement if not capable of unwrapping.
Parameters:
cs - the CallableStatement handle, potentially wrapped by a connection pool the underlying native JDBC CallableStatement, if possible;else, the original Connection
throws:
SQLException - if thrown by JDBC methods |
| getNativeConnection | | Connection getNativeConnection(Connection con) throws SQLException(Code) | | Retrieve the underlying native JDBC Connection for the given Connection.
Supposed to return the given Connection if not capable of unwrapping.
Parameters:
con - the Connection handle, potentially wrapped by a connection pool the underlying native JDBC Connection, if possible;else, the original Connection
throws:
SQLException - if thrown by JDBC methods |
| getNativeConnectionFromStatement | | Connection getNativeConnectionFromStatement(Statement stmt) throws SQLException(Code) | | Retrieve the underlying native JDBC Connection for the given Statement.
Supposed to return the Statement.getConnection() if not
capable of unwrapping.
Having this extra method allows for more efficient unwrapping if data
access code already has a Statement. Statement.getConnection()
often returns the native JDBC Connection even if the Statement itself
is wrapped by a pool.
Parameters:
stmt - the Statement handle, potentially wrapped by a connection pool the underlying native JDBC Connection, if possible;else, the original Connection
throws:
SQLException - if thrown by JDBC methods |
| getNativePreparedStatement | | PreparedStatement getNativePreparedStatement(PreparedStatement ps) throws SQLException(Code) | | Retrieve the underlying native JDBC PreparedStatement for the given statement.
Supposed to return the given PreparedStatement if not capable of unwrapping.
Parameters:
ps - the PreparedStatement handle, potentially wrapped by a connection pool the underlying native JDBC PreparedStatement, if possible;else, the original Connection
throws:
SQLException - if thrown by JDBC methods |
| getNativeResultSet | | ResultSet getNativeResultSet(ResultSet rs) throws SQLException(Code) | | Retrieve the underlying native JDBC ResultSet for the given statement.
Supposed to return the given ResultSet if not capable of unwrapping.
Parameters:
rs - the ResultSet handle, potentially wrapped by a connection pool the underlying native JDBC ResultSet, if possible;else, the original Connection
throws:
SQLException - if thrown by JDBC methods |
| getNativeStatement | | Statement getNativeStatement(Statement stmt) throws SQLException(Code) | | Retrieve the underlying native JDBC Statement for the given Statement.
Supposed to return the given Statement if not capable of unwrapping.
Parameters:
stmt - the Statement handle, potentially wrapped by a connection pool the underlying native JDBC Statement, if possible;else, the original Connection
throws:
SQLException - if thrown by JDBC methods |
| isNativeConnectionNecessaryForNativeCallableStatements | | boolean isNativeConnectionNecessaryForNativeCallableStatements()(Code) | | Return whether it is necessary to work on the native Connection to
receive native CallableStatements.
This should be true if the connection pool does not allow to extract
the native JDBC objects from its CallableStatement wrappers but
supports a way to retrieve the native JDBC Connection. This way,
applications can still receive native Statements and ResultSet via
working on the native JDBC Connection.
|
| isNativeConnectionNecessaryForNativePreparedStatements | | boolean isNativeConnectionNecessaryForNativePreparedStatements()(Code) | | Return whether it is necessary to work on the native Connection to
receive native PreparedStatements.
This should be true if the connection pool does not allow to extract
the native JDBC objects from its PreparedStatement wrappers but
supports a way to retrieve the native JDBC Connection. This way,
applications can still receive native Statements and ResultSet via
working on the native JDBC Connection.
|
| isNativeConnectionNecessaryForNativeStatements | | boolean isNativeConnectionNecessaryForNativeStatements()(Code) | | Return whether it is necessary to work on the native Connection to
receive native Statements.
This should be true if the connection pool does not allow to extract
the native JDBC objects from its Statement wrapper but supports a way
to retrieve the native JDBC Connection. This way, applications can
still receive native Statements and ResultSet via working on the
native JDBC Connection.
|
|
|