All Classes and Interfaces
Class
Description
Beans that must be registered for Spring Data JDBC to work.
Base class for queries based on a repository method.
Factory to create a
RowMapper for a given class.A reference to the aggregate root of a different aggregate.
An
AggregateReference that only holds the id of the referenced aggregate root.Extension to
BasicRelationalPersistentProperty.Delegates each method to the
DataAccessStrategys passed to the constructor in turn until the first that does
not throw an exception.Abstraction for accesses to the database that should be implementable with a single SQL statement per method and
relates to a single entity as opposed to
JdbcAggregateOperations which provides interactions related to
complete aggregates.Factory to create a
DataAccessStrategy based on the configuration of the provided components.The default
DataAccessStrategy is to generate SQL statements based on metadata from the entity.A
JdbcTypeFactory that performs the conversion by utilizing
JdbcOperations.execute(ConnectionCallback).A
QueryMappingConfiguration that allows for registration of RowMappers and
ResultSetExtractors via a fluent Api.Class that provides a default implementation of mapping Java type to a Database type.
Delegates all method calls to an instance set after construction.
Resolves a
Dialect.SPI to extend Spring's default JDBC Dialect discovery mechanism.
Exception thrown when
DialectResolver cannot resolve a Dialect.Annotation to enable auditing in JDBC via annotation configuration.
Annotation to enable JDBC repositories.
Maps a
ResultSet to an entity of type T, including entities referenced.Identifier represents a composite id of an entity that may be composed of one or many parts.
Represents an operation that accepts identifier key parts (name, value and
target type) defining a
contract to consume Identifier values.Factory which selects and builds the appropriate
InsertStrategy or BatchInsertStrategy based on
whether the insert is expected to generate ids.The subject of an insert, described by the entity instance and its
Identifier, where identifier contains
information about data that needs to be considered for the insert but which is not part of the entity.Specifies operations one can perform on a database, based on an Domain Type.
JdbcAggregateOperations implementation, storing aggregates in and obtaining them from a JDBC data store.ArrayColumns that offer JDBC-specific functionality.Default
ArrayColumns implementation for dialects that do not support array-typed columns.Default
ArrayColumns implementation for dialects that do not support array-typed columns.Utility that determines the necessary type conversions between Java types used in the domain model and types
compatible with JDBC drivers.
A
JdbcConverter is responsible for converting for values to the native relational representation and vice
versa.Value object to capture custom conversion.
Db2Dialect that registers JDBC specific converters.ArrayColumns that offer JDBC specific functionality.Builder for
Identifier.MappingContext implementation for JDBC.Db2Dialect that registers JDBC specific converters.Custom extension of
RelationalParameters.Custom
Parameter implementation.JDBC specific Postgres Dialect.
QueryMethod implementation that implements a method by executing the query from a Query annotation on
that method.RepositoryConfigurationExtension extending the repository
registration process by registering JDBC repositories.Creates repository implementation based on JDBC.
Special adapter for Springs
FactoryBean interface to allow easy setup of
repository factories via Spring configuration.Simple constant holder for a
SimpleTypeHolder enriched with specific simple types for relational database
access.SqlServerDialect that registers JDBC specific converters.Allows the creation of instances of database dependent types, e.g.
Contains methods dealing with the quirks of JDBC, independent of any Entity, Aggregate or Repository abstraction.
Wraps a value with the JDBCType that should be used to pass it as a bind parameter to a
PreparedStatement.Helper class to register JSR-310 specific
Converter implementations.Use this class to write Liquibase ChangeSets.
RelationalConverter that uses a MappingContext to apply conversion of relational values to property
values.Indicates a method should be regarded as modifying query.
MyBatisContext instances get passed to MyBatis mapped statements as arguments, making Ids, instances,
domainType and other attributes available to the statements.DataAccessStrategy implementation based on MyBatis.Configuration class tweaking Spring Data JDBC to use a
MyBatisDataAccessStrategy instead of the default one.A strategy to derive a MyBatis namespace from a domainType.
An
AbstractJdbcQuery implementation based on a PartTree.Annotation to provide SQL statements that will get used for executing the method.
Maps
CriteriaDefinition and Sort objects considering mapping metadata and dialect-specific
conversion.Value object to represent a field and its meta-information.
Extension of
QueryMapper.Field to be backed with mapping metadata.Resolves relations within an aggregate.
Delegate to run
scroll queries and create result Window.Default implementation of the
CrudRepository interface.Provides
SqlGenerators per domain type.Creates the
SqlIdentifierParameterSource for various SQL operations, dialect identifier processing rules and
applicable converters.Strategy interface for mapping a
RelationalPersistentProperty to a Database type.A query to be executed based on a repository method, it's annotated SQL query and the arguments provided to the
method.
Signals failure to set the id property of an entity.