All Classes and Interfaces
Class
Description
Abstract base class for
DataFieldMaxValueIncrementer implementations that use
a column in a custom sequence table.Base implementation of
DataFieldMaxValueIncrementer that delegates
to a single AbstractDataFieldMaxValueIncrementer.getNextKey() template method that returns a long.Abstract base class for Spring's
DataSource
implementations, taking care of the padding.Abstract base class for JDBC
DataSource implementations
that operate on a JDBC Driver.Base class for
SQLExceptionTranslator implementations that allow for
fallback to some other SQLExceptionTranslator.Abstract base class for
DataFieldMaxValueIncrementer implementations
which are based on identity columns in a sequence-like table.Abstract implementation of the
InterruptibleBatchPreparedStatementSetter
interface, combining the check for available values and setting of those
into a single callback method AbstractInterruptibleBatchPreparedStatementSetter.setValuesIfAvailable(java.sql.PreparedStatement, int).Abstract class to provide base functionality for easy stored procedure calls
based on configuration options and database meta-data.
Abstract class to provide base functionality for easy inserts
based on configuration options and database meta-data.
Abstract
PreparedStatementCallback implementation that manages a LobCreator.Abstract base class for
LobHandler implementations.Abstract ResultSetExtractor implementation that assumes streaming of LOB data.
Abstract
DataSource implementation that routes AbstractRoutingDataSource.getConnection()
calls to one of various target DataSources based on a lookup key.Abstract base class for
DataFieldMaxValueIncrementer implementations that use
a database sequence.Abstract base class for
SqlParameterSource implementations.Abstract implementation of the SqlTypeValue interface, for convenient
creation of type values that are supposed to be passed into the
PreparedStatement.setObject method.Simple adapter for
PreparedStatementSetter that applies a given array of arguments.Simple adapter for
PreparedStatementSetter that applies
given arrays of arguments and JDBC argument types.Exception thrown when SQL specified is invalid.
Batch update callback interface used by the
JdbcTemplate class.SqlUpdate subclass that performs batch update operations.
DataSourceLookup implementation based on a Spring BeanFactory.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.Generic callback interface for code that operates on a CallableStatement.
One of the three central callback interfaces used by the JdbcTemplate class.
Helper class that efficiently creates multiple
CallableStatementCreator
objects with different parameters based on an SQL statement and a single
set of parameter declarations.Class to manage context meta-data used for the configuration
and execution of a stored procedure call.
Interface specifying the API to be implemented by a class providing call meta-data.
Factory used to create a
CallMetaDataProvider implementation
based on the type of database being used.Holder of meta-data for a specific parameter that is used for call processing.
Fatal exception thrown when we can't connect to an RDBMS using JDBC.
Thrown by
ScriptUtils if an SQL script cannot be read.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.Composite
DatabasePopulator that delegates to a list of given
DatabasePopulator implementations, executing all scripts.Generic callback interface for code that operates on a JDBC Connection.
Simple interface to be implemented by handles for a JDBC Connection.
Resource holder wrapping a JDBC
Connection.ConnectionProperties serves as a simple data container that allows
essential JDBC connection properties to be configured consistently,
independent of the actual DataSource
implementation.Subinterface of
Connection to be implemented by
Connection proxies.JavaBean for holding custom JDBC error codes translation for a particular
database.
Registry for custom
SQLExceptionTranslator instances for specific databases.Registry for custom
SQLExceptionTranslator instances associated with
specific databases allowing for overriding translation based on values contained in the configuration file
named "sql-error-codes.xml".A callback interface used by the JdbcUtils class.
Strategy used to populate, initialize, or clean up a database.
Utility methods for executing a
DatabasePopulator.Bean that checks if a database has already started up.
RowMapper implementation that converts a row into a new instance
of the specified mapped target class.Interface that defines contract of incrementing any data store field's
maximum value.
DataSourceFactory encapsulates the creation of a particular
DataSource implementation such as a non-pooling
SimpleDriverDataSource
or a HikariCP pool setup in the shape of a HikariDataSource.Strategy interface for looking up DataSources by name.
Exception to be thrown by a DataSourceLookup implementation,
indicating that the specified DataSource could not be obtained.
PlatformTransactionManager implementation
for a single JDBC DataSource.Helper class that provides static methods for obtaining JDBC
Connections
from a DataSource.DB2 specific implementation for the
CallMetaDataProvider interface.DataFieldMaxValueIncrementer that retrieves the next value
of a given sequence on DB2 LUW (for Linux, Unix and Windows).DataFieldMaxValueIncrementer that retrieves the next value
of a given sequence on DB2 for the mainframe (z/OS, DB2/390, DB2/400).Default implementation of the
LobHandler interface.JDBC
DataSource implementation that delegates all calls
to a given target DataSource.Derby specific implementation for the
CallMetaDataProvider interface.DataFieldMaxValueIncrementer that increments the maximum value of a given Derby table
with the equivalent of an auto-increment column.The Derby specific implementation of
TableMetaDataProvider.Subinterface of
SqlTypeValue that adds a cleanup callback,
to be invoked after the value has been set and the corresponding
statement has been executed.Simple implementation of the standard JDBC
DataSource interface,
configuring the plain old JDBC DriverManager via bean properties, and
returning a new Connection from every getConnection call.EmbeddedDatabase serves as a handle to an embedded database instance.A builder that provides a convenient API for constructing an embedded database.
EmbeddedDatabaseConfigurer encapsulates the configuration required to
create, connect to, and shut down a specific type of embedded database such as
HSQL, H2, or Derby.Factory for creating an
EmbeddedDatabase instance.A subclass of
EmbeddedDatabaseFactory that implements FactoryBean
for registration as a Spring bean.A supported embedded database type.
A simple empty implementation of the
SqlParameterSource interface.The standard implementation of the
KeyHolder interface, to be used for
holding auto-generated keys (as potentially returned by JDBC insert statements).A generic implementation of the
CallMetaDataProvider interface.Concrete implementation making it possible to define the RDBMS stored procedures
in an application context without writing a custom Java implementation class.
A generic implementation of the
TableMetaDataProvider interface
which should provide enough features for all supported databases.DataFieldMaxValueIncrementer that retrieves the next value
of a given H2 sequence.SAP HANA specific implementation for the
CallMetaDataProvider interface.DataFieldMaxValueIncrementer that retrieves the next value
of a given SAP HANA 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.The HSQL specific implementation of
TableMetaDataProvider.Data access exception thrown when a result set did not have the correct column count,
for example when expecting a single column but getting 0 or more than 1 columns.
Extension of the
BatchPreparedStatementSetter interface,
adding a batch exhaustion check.Exception thrown when a ResultSet has been accessed in an invalid fashion.
An adapter for a target
DataSource, applying the current
Spring transaction's isolation level (and potentially specified user credentials)
to every getConnection call.DataSource that routes to one of various target DataSources based on the
current transaction isolation level.
Default implementation of the
SqlXmlHandler interface.Base class for
JdbcTemplate and
other JDBC-accessing DAO helpers, defining common properties such as
DataSource and exception translator.Deprecated.
as of 5.3, in favor of Spring's common bean definition formats
and/or custom reader implementations
Convenient superclass for JDBC-based data access objects.
NamespaceHandler for JDBC configuration namespace.Interface specifying a basic set of JDBC operations.
This is the central class in the JDBC core package.
It simplifies the use of JDBC and helps to avoid common errors.
JdbcAccessor-aligned subclass of the plain DataSourceTransactionManager,
adding common JDBC exception translation for the commit and rollback step.Convenient base class for JDBC-aware transaction objects.
Exception thrown when a JDBC update affects an unexpected number of rows.
Generic utility methods for working with JDBC.
JNDI-based
DataSourceLookup implementation.Interface for retrieving keys, typically used for auto-generated keys
as potentially returned by JDBC insert statements.
Proxy for a target DataSource, fetching actual JDBC Connections lazily,
i.e.
Interface that abstracts potentially database-specific creation of large binary
fields and large text fields.
Abstraction for handling large binary fields and large text fields in
specific databases, no matter if represented as simple types or Large OBjects.
Exception to be thrown when a LOB could not be retrieved.
Simple
DataSourceLookup implementation that relies on a map for doing lookups.Reusable query in which concrete subclasses must implement the abstract
mapRow(ResultSet, int) method to convert each row of the JDBC ResultSet
into an object.
Reusable RDBMS query in which concrete subclasses must implement
the abstract mapRow(ResultSet, int) method to map each row of
the JDBC ResultSet into an object.
SqlParameterSource implementation that holds a given Map of parameters.DataFieldMaxValueIncrementer that retrieves the next value of a given
MariaDB sequence.Exception indicating that something went wrong during JDBC meta-data lookup.
DataFieldMaxValueIncrementer that increments the maximum value of a given MySQL table
with the equivalent of an auto-increment column.Extension of JdbcDaoSupport that exposes a NamedParameterJdbcTemplate as well.
Interface specifying a basic set of JDBC operations allowing the use
of named parameters rather than the traditional '?' placeholders.
Template class with a basic set of JDBC operations, allowing the use
of named parameters rather than traditional '?' placeholders.
Helper methods for named parameter parsing.
Oracle-specific implementation for the
CallMetaDataProvider interface.DataFieldMaxValueIncrementer that retrieves the next value
of a given Oracle sequence.Oracle-specific implementation of the
TableMetaDataProvider.Internal helper for exposing dummy OutputStreams to embedded databases
such as Derby, preventing the creation of a log file.
Interface to be implemented by objects that can close resources
allocated by parameters like
SqlLobValue objects.Parameterized callback interface used by the
JdbcTemplate class for
batch updates.Implement this interface when parameters need to be customized based
on the connection.
Holds information about a parsed SQL statement.
Postgres-specific implementation for the
CallMetaDataProvider interface.DataFieldMaxValueIncrementer that retrieves the next value
of a given PostgreSQL sequence.The PostgreSQL specific implementation of
TableMetaDataProvider.Generic callback interface for code that operates on a PreparedStatement.
One of the two central callback interfaces used by the JdbcTemplate class.
Helper class that efficiently creates multiple
PreparedStatementCreator
objects with different parameters based on an SQL statement and a single
set of parameter declarations.General callback interface used by the
JdbcTemplate class.An "RDBMS operation" is a multithreaded, reusable object representing a query,
update, or stored procedure call.
Populates, initializes, or cleans up a database using SQL scripts defined in
external resources.
Callback interface used by
JdbcTemplate's query methods.Common base class for ResultSet-supporting SqlParameters like
SqlOutParameter and SqlReturnResultSet.The default implementation of Spring's
SqlRowSet interface, wrapping a
ResultSet, catching any SQLExceptions and
translating them to a corresponding Spring InvalidResultSetAccessException.The default implementation of Spring's
SqlRowSetMetaData interface, wrapping a
ResultSetMetaData instance, catching any SQLExceptions
and translating them to a corresponding Spring InvalidResultSetAccessException.An interface used by
JdbcTemplate and
NamedParameterJdbcTemplate for processing rows of a
ResultSet on a per-row basis.Implementation of RowCallbackHandler.
An interface used by
JdbcTemplate for mapping rows of a
ResultSet on a per-row basis.Adapter implementation of the ResultSetExtractor interface that delegates
to a RowMapper which is supposed to create an object for each row.
Root of the hierarchy of data access exceptions that are related to processing
of SQL scripts.
Thrown by
ScriptUtils if an SQL script cannot be properly parsed.Thrown by
ScriptUtils if a statement in an SQL script failed when
executing it against the target database.Generic utility methods for working with SQL scripts in conjunction with JDBC.
Simple implementation of the
ConnectionHandle interface,
containing a given JDBC Connection.Simple implementation of the standard JDBC
DataSource interface,
configuring a plain old JDBC Driver via bean properties, and
returning a new Connection from every getConnection call.A SimpleJdbcCall is a multithreaded, reusable object representing a call
to a stored procedure or a stored function.
Interface specifying the API for a Simple JDBC Call implemented by
SimpleJdbcCall.A SimpleJdbcInsert is a multithreaded, reusable object providing easy insert
capabilities for a table.
Interface specifying the API for a Simple JDBC Insert implemented by
SimpleJdbcInsert.RowMapper implementation that converts a single column into a single
result value per row.Implementation of
SmartDataSource that wraps a single JDBC Connection
which is not closed after use.An implementation of the DataSourceLookup that simply wraps a
single given DataSource, returned for any data source name.
Extension of the
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.RdbmsOperation using a JdbcTemplate and representing an SQL-based
call such as a stored procedure or a stored function.
JavaBean for holding JDBC error codes for a particular database.
Factory for creating
SQLErrorCodes based on the
"databaseProductName" taken from the DatabaseMetaData.Implementation of
SQLExceptionTranslator that analyzes vendor-specific error codes.SQLExceptionTranslator implementation which analyzes the specific
SQLException subclass thrown by the JDBC driver.Strategy interface for translating between
SQLExceptions
and Spring's data access strategy-agnostic DataAccessException
hierarchy.SQL "function" wrapper for a query that returns a single row of results.
Subclass of
SqlOutParameter to represent an INOUT parameter.Object to represent an SQL BLOB/CLOB value parameter.
Operation object representing an SQL-based operation such as a query or update,
as opposed to a stored procedure.
Subclass of
SqlParameter to represent an output parameter.Object to represent an SQL parameter definition.
Interface that defines common functionality for objects that can
offer parameter values for named SQL parameters, serving as argument
for
NamedParameterJdbcTemplate operations.Class that provides helper methods for the use of
SqlParameterSource,
in particular with NamedParameterJdbcTemplate.Object to represent an SQL parameter value, including parameter meta-data
such as the SQL type and the scale for numeric values.
Interface to be implemented by objects that can provide SQL strings.
Reusable operation object representing an SQL query.
Represents a returned
ResultSet from a stored procedure call.Interface to be implemented for retrieving values for more complex database-specific
types not supported by the standard
CallableStatement.getObject method.Represents a returned update count from a stored procedure call.
Metadata interface for Spring's
SqlRowSet, analogous to JDBC's
ResultSetMetaData.ResultSetExtractor implementation that returns a Spring SqlRowSet
representation for each given ResultSet.SQL Server specific implementation for the
CallMetaDataProvider interface.DataFieldMaxValueIncrementer that increments the maximum value of a given SQL Server table
with the equivalent of an auto-increment column.DataFieldMaxValueIncrementer that retrieves the next value of a given
SQL Server sequence.SQLExceptionTranslator implementation that analyzes the SQL state in
the SQLException based on the first two digits (the SQL state "class").Interface to be implemented for setting values for more complex database-specific
types not supported by the standard
setObject method.Reusable operation object representing an SQL update.
Simple interface for complex types to be set as statement parameters.
Exception thrown when we're not ignoring
SQLWarnings.Exception thrown when the underlying implementation does not support the
requested feature of the API.
Abstraction for handling XML fields in specific databases.
Subinterface of
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.Generic callback interface for code that operates on a JDBC Statement.
Utility methods for PreparedStatementSetter/Creator and CallableStatementCreator
implementations, providing sophisticated parameter management (including support
for LOB values).
Superclass for object abstractions of RDBMS stored procedures.
DataFieldMaxValueIncrementer that increments the maximum value of a given Sybase table
with the equivalent of an auto-increment column.Sybase specific implementation for the
CallMetaDataProvider interface.DataFieldMaxValueIncrementer that increments the maximum value of a given Sybase table
with the equivalent of an auto-increment column.Class to manage context meta-data used for the configuration
and execution of operations on a database table.
Interface specifying the API to be implemented by a class providing table meta-data.
Factory used to create a
TableMetaDataProvider implementation
based on the type of database being used.Holder of meta-data for a specific parameter that is used for table processing.
LobCreator implementation based on temporary LOBs,
using JDBC 4.0's Connection.createBlob() /
Connection.createClob() mechanism.Proxy for a target JDBC
DataSource, adding awareness of
Spring-managed transactions.Thrown when we cannot determine anything more specific than "something went
wrong while processing an SQL script": for example, a
SQLException
from JDBC that we cannot pinpoint more precisely.Exception thrown when we can't classify an SQLException into
one of our generic data access exceptions.
Reusable RDBMS query in which concrete subclasses must implement
the abstract updateRow(ResultSet, int, context) method to update each
row of the JDBC ResultSet and optionally map contents into an object.
An adapter for a target JDBC
DataSource, applying the specified
user credentials to every standard getConnection() call, implicitly
invoking getConnection(username, password) on the target.Interface defining handling involved with providing
OutputStream
data for XML input.Interface defining handling involved with providing
Writer
data for XML input.Interface defining handling involved with providing
Result
data for XML input.