|
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.ResultSetMetaDataCallMetaDataProvider 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 | ||||||||