public interface NativeJdbcExtractor
OracleConnection
or OracleResultSet
in application
code, for example to create Blobs or to access vendor-specific features.
Note: Setting a custom NativeJdbcExtractor
is just necessary
if you intend to cast to database-specific implementations like
OracleConnection
or OracleResultSet
.
Otherwise, any wrapped JDBC object will be fine, with no need for unwrapping.
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, unwrapping all JDBC objects
that it creates. Note that this is just necessary if you intend to cast to
native implementations in your data access code.
OracleLobHandler
,
the Oracle-specific implementation of Spring's
LobHandler
interface, requires a
NativeJdbcExtractor
for obtaining the native OracleConnection
.
This is also necessary for other Oracle-specific features that you may want
to leverage in your applications, such as Oracle InterMedia.
SimpleNativeJdbcExtractor
,
CommonsDbcpNativeJdbcExtractor
,
JdbcTemplate.setNativeJdbcExtractor(org.springframework.jdbc.support.nativejdbc.NativeJdbcExtractor)
,
OracleLobHandler.setNativeJdbcExtractor(org.springframework.jdbc.support.nativejdbc.NativeJdbcExtractor)
Modifier and Type | Method and Description |
---|---|
CallableStatement |
getNativeCallableStatement(CallableStatement cs)
Retrieve the underlying native JDBC CallableStatement for the given statement.
|
Connection |
getNativeConnection(Connection con)
Retrieve the underlying native JDBC Connection for the given Connection.
|
Connection |
getNativeConnectionFromStatement(Statement stmt)
Retrieve the underlying native JDBC Connection for the given Statement.
|
PreparedStatement |
getNativePreparedStatement(PreparedStatement ps)
Retrieve the underlying native JDBC PreparedStatement for the given statement.
|
ResultSet |
getNativeResultSet(ResultSet rs)
Retrieve the underlying native JDBC ResultSet for the given statement.
|
Statement |
getNativeStatement(Statement stmt)
Retrieve the underlying native JDBC Statement for the given Statement.
|
boolean |
isNativeConnectionNecessaryForNativeCallableStatements()
Return whether it is necessary to work on the native Connection to
receive native CallableStatements.
|
boolean |
isNativeConnectionNecessaryForNativePreparedStatements()
Return whether it is necessary to work on the native Connection to
receive native PreparedStatements.
|
boolean |
isNativeConnectionNecessaryForNativeStatements()
Return whether it is necessary to work on the native Connection to
receive native Statements.
|
boolean isNativeConnectionNecessaryForNativeStatements()
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.
boolean isNativeConnectionNecessaryForNativePreparedStatements()
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.
boolean isNativeConnectionNecessaryForNativeCallableStatements()
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.
Connection getNativeConnection(Connection con) throws SQLException
con
- the Connection handle, potentially wrapped by a connection poolSQLException
- if thrown by JDBC methodsConnection getNativeConnectionFromStatement(Statement stmt) throws SQLException
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.
stmt
- the Statement handle, potentially wrapped by a connection poolSQLException
- if thrown by JDBC methodsStatement.getConnection()
Statement getNativeStatement(Statement stmt) throws SQLException
stmt
- the Statement handle, potentially wrapped by a connection poolSQLException
- if thrown by JDBC methodsPreparedStatement getNativePreparedStatement(PreparedStatement ps) throws SQLException
ps
- the PreparedStatement handle, potentially wrapped by a connection poolSQLException
- if thrown by JDBC methodsCallableStatement getNativeCallableStatement(CallableStatement cs) throws SQLException
cs
- the CallableStatement handle, potentially wrapped by a connection poolSQLException
- if thrown by JDBC methodsResultSet getNativeResultSet(ResultSet rs) throws SQLException
rs
- the ResultSet handle, potentially wrapped by a connection poolSQLException
- if thrown by JDBC methods