|
spring-jdbc | ||||||||
PREV NEXT | FRAMES NO FRAMES |
DataFieldMaxValueIncrementer
implementations that use
a column in a custom sequence table.DataFieldMaxValueIncrementer
that delegates
to a single AbstractDataFieldMaxValueIncrementer.getNextKey()
template method that returns a long
.DataSource
implementations, taking care of the padding.DataSource
implementations
that operate on a JDBC Driver
.SQLExceptionTranslator
implementations that allow for
fallback to some other SQLExceptionTranslator
.InterruptibleBatchPreparedStatementSetter
interface, combining the check for available values and setting of those
into a single callback method AbstractInterruptibleBatchPreparedStatementSetter.setValuesIfAvailable(java.sql.PreparedStatement, int)
.DataSource
.
JdbcTemplate
.
DataSource
implementation that routes AbstractRoutingDataSource.getConnection()
calls to one of various target DataSources based on a lookup key.DataFieldMaxValueIncrementer
implementations that use
a database sequence.SqlParameterSource
implementations.PreparedStatement.setObject
method.DataSource
to the map of DataSources
maintained by this object.
RowMapper
for the specified parameter or column.
AbstractJdbcCall.addDeclaredRowMapper(String, org.springframework.jdbc.core.RowMapper)
JdbcTemplate
class.DataSourceLookup
implementation based on a Spring BeanFactory
.BeanFactoryDataSourceLookup
class.
BeanFactoryDataSourceLookup
class.
RowMapper
implementation that converts a row into a new instance
of the specified mapped target class.SqlParameterSource
implementation that obtains parameter values
from bean properties of a given JavaBean object.String
for the given SQLException
.
NativeJdbcExtractor
interface for the
C3P0 connection pool.CallableStatementCreator
objects with different parameters based on a SQL statement and a single
set of parameter declarations.CallMetaDataProvider
implementation based on the type of databse being used.ResourceDatabasePopulator
if one of its SQL scripts could
not be read during population.RowMapper
implementation that creates a java.util.Map
for each row, representing all columns as key-value pairs: one
entry for each column, with the column name as key.NativeJdbcExtractor
interface for the
Jakarta Commons DBCP connection pool, version 1.1 or higher.DatabasePopulator
implementation that delegates to a list of other
DatabasePopulator implementations, executing all scripts.SimpleConnectionHandle
,
assuming that there is no ongoing transaction.
SimpleConnectionHandle
.
Connection
to be implemented by
Connection proxies.JDBCConnectionSpec
object for the given charateristics.
Types
based on configuration and metadata information
PreparedStatement.setObject
.
SQLExceptionTranslator
instances for specific databases.SQLExceptionTranslator
instances associated with
specific databases allowing for overriding translation based on values contained in the configuration file
named "sql-error-codes.xml".SimpleDriverDataSource
or connection pool such as Apache DBCP or C3P0.PlatformTransactionManager
implementation for a single JDBC DataSource
.DataSource
.CallMetaDataProvider
interface.DataFieldMaxValueIncrementer
that retrieves the next value of a given sequence
on DB2/390 or DB2/400.DataFieldMaxValueIncrementer
that retrieves the next value of a given sequence
on DB2 UDB (for Unix and Windows).LobHandler
interface.DataSource
implementation that delegates all calls
to a given target DataSource
.CallMetaDataProvider
interface.DataFieldMaxValueIncrementer
that increments the maximum value of a given Derby table
with the equivalent of an auto-increment column.TableMetaDataProvider
.SqlTypeValue
that adds a cleanup callback,
to be invoked after the value has been set and the corresponding
statement has been executed.SqlParameterSource
SqlParameterSource
SqlParameterSource
and returning a generated key
SqlParameterSource
and returning all generated keys
SqlParameterSource
getConnection(username, password)
method of the target DataSource, passing in the specified user credentials.
WSDataSource.getConnection(JDBCConnectionSpec)
.
rawConnectionOperation
API,
using the getRawConnection
as callback to get access to the
raw Connection (which is otherwise not directly supported by C3P0).
getUnderlyingConnection
method.
getVendorConnection
method.
getNativeConnection
method.
JdbcTemplate.execute
with an active JDBC
CallableStatement.
JdbcTemplate.execute
with an active JDBC
Connection.
JdbcTemplate.execute
with an active JDBC
PreparedStatement.
JdbcTemplate.execute
with an active JDBC
Statement.
DataSource
interface,
configuring the plain old JDBC DriverManager
via bean properties, and
returning a new Connection
from every getConnection
call.SimpleDriverDataSource
instead.
EmbeddedDatabase
instance.EmbeddedDatabaseFactory
that implements FactoryBean
for registration as a Spring bean.findObject
methods.
KeyHolder
interface, to be used for
holding auto-generated keys (as potentially returned by JDBC insert statements).CallMetaDataProvider
interface.TableMetaDataProvider
that should provide
enough features for all supported databases.Integer.MAX_VALUE
.
CallableStatementCreatorFactory
being used
getConnectionFromDriver
,
using the default username and password of this DataSource.
getConnectionFromDriver
,
using the given username and password.
UserCredentialsDataSourceAdapter.doGetConnection(String, String)
,
keeping the given user credentials as-is.
Map
of DataSources
maintained by this object.
SqlParameter
objects.
SQLErrorCodes
instance for the given database.
SQLErrorCodes
for the given DataSource
,
evaluating "databaseProductName" from the
DatabaseMetaData
, or an empty error codes
instance if no SQLErrorCodes
were found.
Types
to be used for insert
null
if none.
JdbcTemplate
JdbcTemplate
that is configured to be used
LobCreator
instance, i.e.
getUnderlyingStatement
method.
getUnderlyingStatement
method.
getUnderlyingResultSet
method.
getUnderlyingStatement
method.
AbstractSequenceMaxValueIncrementer.getSequenceQuery()
.
OutputStream
that ignores all data given to it.
Types
type for columns that return resultsets as ref cursors if this feature
is supported.
javax.sql.rowset.CachedRowSet
).
close()
calls to DataSourceUtils.
DataFieldMaxValueIncrementer
that retrieves the next value of a given H2 Database sequence.DataFieldMaxValueIncrementer
that increments the maximum value of a given HSQL table
with the equivalent of an auto-increment column.DataFieldMaxValueIncrementer
that retrieves the next value of a given HSQL sequence.TableMetaDataProvider
.oracle.sql.BLOB
and oracle.sql.CLOB
classes via reflection, and initialize the values for the
DURATION_SESSION, MODE_READWRITE and MODE_READONLY constants defined there.
BatchPreparedStatementSetter
interface,
adding a batch exhaustion check.setValues
call.
Connection.createStruct(String, Object[])
?
Connection.createStruct(String, Object[])
DatabaseMetaData.supportsGetGeneratedKeys()
DatabaseMetaData.supportsGetGeneratedKeys()
?
DatabaseMetaData.supportsGetGeneratedKeys()
false
.
true
.
null
.
null
.
false
by default.
true
, as WebLogic returns wrapped CallableStatements.
true
, as WebSphere returns wrapped CallableStatements.
false
by default.
true
, as WebLogic returns wrapped PreparedStatements.
true
, as WebSphere returns wrapped PreparedStatements.
false
by default.
true
, as WebLogic returns wrapped Statements.
true
, as WebSphere returns wrapped Statements.
DataSource
, applying the current
Spring transaction's isolation level (and potentially specified user credentials)
to every getConnection
call.CallableStatement.getObject(int)
for the specified column.
Statement.getResultSet()
NativeJdbcExtractor
interface for JBoss,
supporting JBoss Application Server 3.2.4+.NativeJdbcExtractor
implementation that delegates to JDBC 4.0's
unwrap
method, as defined by Wrapper
.SqlXmlHandler
interface.JdbcTemplate
and
other JDBC-accessing DAO helpers, defining common properties such as
DataSource and exception translator.NamespaceHandler
for JDBC configuration namespace.DataSourceLookup
implementation.DataSourceLookup
implementation that relies on a map for doing lookups.MapDataSourceLookup
class.
MapDataSourceLookup
class.
MapDataSourceLookup
class.
mapRow
method for each row.SqlParameterSource
implementation that holds a given Map of parameters.addValue
.
DataFieldMaxValueIncrementer
that increments the maximum value of a given MySQL table
with the equivalent of an auto-increment column.DataSource
.
JdbcTemplate
.
NativeJdbcExtractor
interface,
for simplified implementation of basic extractors.createSqlRowSet
implementation.
SqlXmlValue
implementation to be used together
with the database specific implementation of this SqlXmlObjectMappingHandler
.
List
.
SqlXmlValue
instance for the given XML data,
as supported by the underlying JDBC driver.
SqlXmlValue
instance for the given XML data,
as supported by the underlying JDBC driver.
SqlXmlValue
instance for the given XML data,
as supported by the underlying JDBC driver.
SqlXmlValue
instance for the given XML data,
as supported by the underlying JDBC driver.
SqlXmlValue
instance for the given XML data,
as supported by the underlying JDBC driver.
CallMetaDataProvider
interface.Jdbc4NativeJdbcExtractor
which comes pre-configured for Oracle's JDBC driver,
specifying the following vendor-specific API types for unwrapping:
oracle.jdbc.OracleConnection
oracle.jdbc.OracleStatement
oracle.jdbc.OraclePreparedStatement
oracle.jdbc.OracleCallableStatement
oracle.jdbc.OracleResultSet
LobHandler
implementation for Oracle databases.DataFieldMaxValueIncrementer
that retrieves the next value of a given Oracle sequence.TableMetaDataProvider
.org.springframework.jdbc.core
package.ParameterizedRowMapper
implementation that converts a row into a new instance
of the specified mapped target class.JdbcTemplate
class for batch updates.RowMapper
interface,
adding type parameterization.ParameterizedRowMapper
implementation that converts a single column
into a single result value per row.CallMetaDataProvider
interface.DataFieldMaxValueIncrementer
that retrieves the next value of a given PostgreSQL sequence.TableMetaDataProvider
.PreparedStatementCreator
objects with different parameters based on a SQL statement and a single
set of parameter declarations.JdbcTemplate
class.OutputStream
.
Writer
.
Result
.
List
of Objects
of type T
using
the supplied RowMapper
to the query results to the object.
List
of Objects
of type T
using
the supplied RowMapper
to the query results to the object.
List
of Objects
of type T
using
the supplied RowMapper
to the query results to the object.
int
passing in a SQL query
using the named parameter support provided by the
NamedParameterJdbcTemplate
and a map containing the arguments.
int
passing in a SQL query
using the named parameter support provided by the
NamedParameterJdbcTemplate
and a SqlParameterSource
containing the arguments.
int
passing in a SQL query
using the standard '?' placeholders for parameters
and a variable number of arguments.
long
passing in a SQL query
using the named parameter support provided by the
NamedParameterJdbcTemplate
and a map containing the arguments.
long
passing in a SQL query
using the named parameter support provided by the
NamedParameterJdbcTemplate
and a SqlParameterSource
containing the arguments.
long
passing in a SQL query
using the standard '?' placeholders for parameters
and a variable number of arguments.
T
identified by the supplied @Class
.
T
identified by the supplied @Class
.
T
identified by the supplied @Class
.
T
using the supplied
RowMapper
to the query results to the object.
T
using the supplied
RowMapper
to the query results to the object.
T
using the supplied
RowMapper
to the query results to the object.
DataSource
.
targetDataSources
map, into
the actual lookup key to be used for matching with the
current lookup key
.
TransactionDefinition interface
.
JdbcTemplate
's query methods.SqlOutParameter
and SqlReturnResultSet
.SqlRowSet
interface.SimpleJdbcCall.returningResultSet(String, org.springframework.jdbc.core.RowMapper)
SimpleJdbcCallOperations.returningResultSet(String, org.springframework.jdbc.core.RowMapper)
JdbcTemplate
for processing rows of a
ResultSet
on a per-row basis.JdbcTemplate
for mapping rows of a
ResultSet
on a per-row basis.SqlQuery.findObject(Object[])
method.
ResourceDatabasePopulator
if a statement in one of its SQL scripts
failed when executing it against the target database.DatabasePopulator
to use to populate the data source.
DataSource
to populate when this component is initialized.
targetDataSources
map.
Map
of DataSources
; the keys
are Strings
, the values are actual DataSource
instances.
Connection
, e.g.
SQLStateSQLExceptionTranslator
).
DROP
statement can be ignored.
Connection
constants
(equivalent to the corresponding Spring
TransactionDefinition
constants).
TransactionDefinition
, e.g.
NativeJdbcExtractor
to be used to retrieve the native connection.
NativeJdbcExtractor
to use to retrieve the native connection if necessary
NativeJdbcExtractor
to use to retrieve the native connection if necessary
oracle.jdbc.OracleConnection
.
setBlob
/
setClob
method with a stream argument.
SQLExceptionTranslator
references where the key must
be the database name as defined in the sql-error-codes.xml
file.
java.sql.Types
class.
AbstractInterruptibleBatchPreparedStatementSetter.setValuesIfAvailable(java.sql.PreparedStatement, int)
and sets this instance's exhaustion flag accordingly.
setBlob
/
setClob
method with a Blob / Clob argument.
ConnectionHandle
interface,
containing a given JDBC Connection.DataSource
interface,
configuring a plain old JDBC Driver
via bean properties, and returning
a new Connection
from every getConnection
call.SimpleJdbcCall
.JdbcDaoSupport
and
NamedParameterJdbcDaoSupport
. The JdbcTemplate and
NamedParameterJdbcTemplate now provide all the functionality of the SimpleJdbcTemplate.SimpleJdbcInsert
.JdbcOperations
and
NamedParameterJdbcOperations
. The JdbcTemplate and
NamedParameterJdbcTemplate now provide all the functionality of the SimpleJdbcTemplate.JdbcTemplate
and
NamedParameterJdbcTemplate
. The JdbcTemplate and
NamedParameterJdbcTemplate now provide all the functionality of the SimpleJdbcTemplate.NativeJdbcExtractor
interface.RowMapper
implementation that converts a single column into a single
result value per row.SmartDataSource
that wraps a single JDBC Connection
which is not closed after use.SingleDataSourceLookup
class.
javax.sql.DataSource
interface, to be
implemented by special DataSources that return JDBC Connections
in an unwrapped fashion.FactoryBean
implementation that takes a list of location Strings
and creates a sorted array of Resource
instances.SQLErrorCodes
based on the
"databaseProductName" taken from the DatabaseMetaData
.SQLErrorCodesFactory
class.
SQLExceptionTranslator
that analyzes vendor-specific error codes.SQLExceptionTranslator
implementation which analyzes the specific
SQLException
subclass thrown by the JDBC driver.SQLExceptions
and Spring's data access strategy-agnostic DataAccessException
hierarchy.SqlOutParameter
to represent an INOUT parameter.NamedParameterJdbcTemplate
operations.SqlParameterSource
with SimpleJdbc
classes.DataSource
and SQL string.
ResultSet
from a stored procedure call.SqlReturnResultSet
class.
SqlReturnResultSet
class.
SqlReturnResultSet
class.
CallableStatement.getObject
method.SqlReturnUpdateCount
class.
javax.sql.RowSet
, representing
disconnected java.sql.ResultSet
data.javax.sql.ResultSetMetaData
CallMetaDataProvider
interface.DataFieldMaxValueIncrementer
that increments the maximum value of a given SQL Server table
with the equivalent of an auto-increment column.SQLExceptionTranslator
implementation that analyzes the SQL state in
the SQLException
based on the first two digits (the SQL state "class").java.sql.Types
,
to a List of SqlParameter objects as used in this package.
setObject
method.SQLWarnings
.SqlValue
that supports passing in XML data to specified column and adds a
cleanup callback, to be invoked after the value has been set and
the corresponding statement has been executed.DataFieldMaxValueIncrementer
that increments
the maximum value of a given Sybase SQL Anywhere table
with the equivalent of an auto-increment column.CallMetaDataProvider
interface.DataFieldMaxValueIncrementer
that increments
the maximum value of a given Sybase SQL Server table
with the equivalent of an auto-increment column.TableMetaDataProvider
implementation based on the type of databse being used.DataSource
, adding awareness of
Spring-managed transactions.AbstractFallbackSQLExceptionTranslator.doTranslate(java.lang.String, java.lang.String, java.sql.SQLException)
, and invokes the
fallback translator
if necessary.
SQLException
into a generic DataAccessException
.
updateRow()
method for each row.update
that adds the given statement
parameters to the queue rather than executing them immediately.
DataSource
, applying the specified
user credentials to every standard getConnection()
call, implicitly
invoking getConnection(username, password)
on the target.NULL
.
NativeJdbcExtractor
interface for WebLogic,
supporting WebLogic Server 8.1 and higher.DataSource
implementation that delegates all calls to a WebSphere
target DataSource
, typically obtained from JNDI, applying a current
isolation level and/or current user credentials to every Connection obtained
from it.NativeJdbcExtractor
interface for WebSphere,
supporting WebSphere Application Server 5.1 and higher.OutputStream
data for XML input.Writer
data for XML input.Result
data for XML input.
|
spring-jdbc | ||||||||
PREV NEXT | FRAMES NO FRAMES |