All Classes and Interfaces
Class
Description
Base class for
Dialect implementations.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.Base class for Spring Data R2DBC configuration containing bean declarations that must be registered for Spring Data
R2DBC to work.
Base class for reactive
RepositoryQuery implementations for R2DBC.Base class for
RelationalConverter implementations.Base class for mapping events of Spring Data Relational
Base class to implement domain class specific
ApplicationListener classes.Callback being invoked after a domain object is materialized from a row when reading results.
An
EntityCallback that gets invoked after an aggregate was converted from the database into an entity.Gets published after instantiation and setting of all the properties of an entity.
An
EntityCallback that gets called after an aggregate got deleted.Gets published after deletion of an entity.
Entity callback triggered after save of a
OutboundRow.An
EntityCallback that gets invoked after an aggregate was saved to the database.Gets published after a new instance or a changed instance was saved in the database.
Represents the change happening to the aggregate (as used in the context of Domain Driven Design) as a whole.
The kind of action to be performed on an aggregate.
Represents a path within an aggregate starting from the aggregate root.
A reference to the aggregate root of a different aggregate.
An
AggregateReference that only holds the id of the referenced aggregate root.Aliased element exposing an
alias.An expression with an alias.
Creates aliases to be used in SQL generation
Represents an analytic function, also known as windowing function
An SQL dialect for the ANSI SQL standard.
Interface declaring methods that express how a dialect supports array-typed columns.
Default
ArrayColumns implementation for dialects that do not support array-typed columns.Utilities for array interaction.
Update assignment to a
Column.Factory for common
Assignments.Assign a
Expression to a Column.Deprecated.
Extension to
BasicRelationalPersistentProperty.Deprecated.
since 3.2, use
MappingRelationalConverter instead as the naming suggests a limited scope of
functionality.SQL-specific
PersistentProperty implementation.Represents the changes happening to one or more aggregates (as used in the context of Domain Driven Design) as a
whole.
Deprecated.
since 3.2.
Callback being invoked before a domain object is converted to be persisted.
An
EntityCallback that gets invoked before the aggregate is converted into a database change.Gets published before an aggregate gets converted into a database change, but after the decision was made if an
insert or an update is to be performed.
An
EntityCallback that gets invoked before an entity is deleted.Gets published when an entity is about to get deleted.
Entity callback triggered before save of a row.
An
EntityCallback that gets invoked before changes are applied to the database, after the aggregate was
converted to a database change.Gets published before changes are applied to the database, after the aggregate was converted to a database change.
BETWEEN
Condition comparing between Expressions.Interface declaring a query that supplies SQL and can bind parameters to a
DatabaseClient.GenericExecuteSpec.Bind marker/parameter placeholder used to construct prepared statements with parameter substitution.
Utility to bind
Parameter to a BindTarget.Represents a
Boolean literal.Value object representing
Assignments with their Bindings.Delegates each method to the
DataAccessStrategys passed to the constructor in turn until the first that does
not throw an exception.Represents a
CAST expression like CAST(something AS JSON.The annotation to configure the mapping from an attribute to a database column.
Column name within a
SELECT … FROM clause.Comparing
Condition comparing two Expressions.AST
Segment for a condition.Factory for common
Conditions.Condition representing fixed sql predicate.Central class for creating queries.
Interface declaring terminal builder methods to build a
Criteria.Interface defining a criteria definition object.
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.An SQL dialect for DB2.
An instance of this interface represents a (conceptual) single interaction with a database, e.g. a single update,
used as a step when synchronizing the state of an aggregate with the database.
Represents an acquire lock statement for all aggregate roots of a given type.
Represents an acquire lock statement for a aggregate root when only the ID is known.
Represents a batch delete statement for multiple entities that are reachable via a given path from the aggregate
root.
Represents a batch delete statement for multiple entities that are aggregate roots.
Represents a batch insert statement for a multiple entities that are not aggregate roots.
Represents a batch insert statement for a multiple entities that are aggregate roots.
Represents a batch of
DbAction that share a common value for a property of the action.Represents a delete statement for all entities that that a reachable via a give path from the aggregate root.
Represents an delete statement for all entities that that a reachable via a give path from any aggregate root of a
given type.
Represents a delete statement for all aggregate roots of a given type.
Represents a delete statement for a aggregate root when only the ID is known.
Represents an insert statement for a single entity that is not the root of an aggregate.
Represents an insert statement for the root of an aggregate.
Represents an update statement for the aggregate root.
An action depending on another action for providing additional information like the id of a parent entity.
A
DbAction that stores the information of a single entity in the database.A
DbAction not operation on the root of an aggregate but on its contained entities.A
DbAction pertaining to the root on an aggregate.Exception thrown when during the execution of a
DbAction an exception gets thrown.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).The default naming strategy used by Spring Data Relational.
A
QueryMappingConfiguration that allows for registration of RowMappers and
ResultSetExtractors via a fluent Api.Default
ReactiveDataAccessStrategy implementation.Class that provides a default implementation of mapping Java type to a Database type.
Delegates all method calls to an instance set after construction.
AST for a
DELETE statement.Represents the change happening to the aggregate (as used in the context of Domain Driven Design) as a whole.
A
BatchingAggregateChange implementation for delete changes that can contain actions for one or more delete
operations.Entry point to construct a
Delete statement.Interface exposing the
Delete build method.Interface exposing
WHERE methods.Represents a dialect that is implemented by a particular database.
Resolves a
Dialect.SPI to extend Spring's default JDBC Dialect discovery mechanism.
Exception thrown when
DialectResolver cannot resolve a Dialect.Exception thrown when
DialectResolver cannot resolve a R2dbcDialect.SPI to extend Spring's default R2DBC Dialect discovery mechanism.
The annotation to configure a value object as embedded in the current table.
Shortcut for an empty embedded property.
Shortcut for a nullable embedded property.
Load strategy to be used
Embedded.onEmpty().Annotation to enable auditing in JDBC via annotation configuration.
Annotation to enable JDBC repositories.
Annotation to enable auditing in R2DBC via annotation configuration.
Annotation to activate reactive relational repositories using R2DBC.
Delegate class to encapsulate lifecycle event configuration and publishing.
Maps a
ResultSet to an entity of type T, including entities referenced.Maps a
Row to an entity of type T, including entities referenced.Support class to natively write
Enum values to the database.Helper class encapsulating an escape character for LIKE queries and the actually usage of it in escaping
Strings.Expression that can be used in select lists.
Factory for common
Expressions.Simple condition that evaluates to SQL
FALSE.Stripped down interface providing access to a fluent API that specifies a basic set of reactive R2DBC operations.
Enum for determining how the names of back references should get generated.
FROM clause.Factory for common
function expressions.R2DBC dialect for H2.
An SQL dialect for H2.
A
Dialect for HsqlDb.Identifier represents a composite id of an entity that may be composed of one or many parts.
Wrapper for an identifier of an entity.
Represents an operation that accepts identifier key parts (name, value and
target type) defining a
contract to consume Identifier values.An interface describing the processing steps for the conversion of
SqlIdentifier to SQL snippets or column
names.Encapsulates the three kinds of letter casing supported.
A conversion from unquoted identifiers to quoted identifiers.
Describes how obtaining generated ids after an insert works for a given JDBC driver.
Enumeration describing the source of a value for an id property.
IN Condition clause.Represents a inline query within a SQL statement.
AST for a
INSERT statement.Entry point to construct an
Insert statement.Interface exposing the
Insert build method.Interface exposing
WHERE methods.Interface exposing
value methods to add values to the INSERT statement and the build method.Interface exposing
value methods to add values to the INSERT statement.Interface exposing
value methods to add values to the INSERT statement and the build method.A property with this annotation will only be written to the database during insert operations, not during updates.
This interface encapsulates the details about how to process
Insert SQL statementIn the scope of Insert with default values SQL statement, for example INSERT INTO SCHEMA.TABLE VALUES
(DEFAULT) this enum represents the default values part in different
DialectsFactory 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.This interface aggregates information about an Insert with default values statement.
INTO clause.IS NULL Condition.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.Segment for a JOIN declaration.Helper class to register JSR-310 specific
Converter implementations.LIKE
Condition comparing two Expressions.A clause representing Dialect-specific
LIMIT.Enumeration of where to render the clause within the SQL statement.
Use this class to write Liquibase ChangeSets.
Represents a literal.
Annotation to provide a lock mode for a given query.
A clause representing Dialect-specific
LOCK.Enumeration of where to render the clause within the SQL statement.
Lock Mode Types of SELECT statements.
Value object providing lock options to apply to a
Select statement.RelationalConverter that uses a MappingContext to apply conversion of relational values to property
values.Converter for R2DBC.
RelationalConverter that uses a
MappingContext to apply sophisticated mapping of domain objects from
RowDocument.MappingRelationalConverter.RelationalPropertyValueProvider extension to obtain values for AggregatePaths.Conversion context defining an interface for graph-traversal-based conversion of row documents.
Conversion context holding references to simple
MappingRelationalConverter.DefaultConversionContext.ValueConverter and MappingRelationalConverter.DefaultConversionContext.ContainerValueConverter.Converts a container
source value into the target type.Converts a simple
source value into the target type.PropertyValueProvider to evaluate a SpEL expression if present on the property or simply accesses the field
of the configured source RowDocument.Extended
ParameterValueProvider that can report whether a property value is present and contextualize the
instance for specific behavior like projection mapping in the context of a property.RelationalEntityInformation implementation using a RelationalPersistentEntity instance to lookup the
necessary information.A SQL dialect for MariaDb.
Indicates a method should be regarded as modifying query.
Indicates a query method should be considered a modifying query that returns nothing or the number of rows affected
by the query.
Wrapper for multiple
Conditions.Represents the change happening to the aggregate (as used in the context of Domain Driven Design) as a whole.
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.An SQL dialect for MySQL.
A SQL dialect for MySQL.
Named element exposing a
name.A strategy to derive a MyBatis namespace from a domainType.
Factory for
RenderNamingStrategy objects.Interface and default implementation of a naming strategy.
Condition group wrapping a nested
Condition with parentheses.Represents a
Number literal.ArrayColumns support using the actual object type or boxed primitives Java types.A path of objects nested into each other.
An SQL dialect for Oracle.
An SQL dialect for Oracle.
Represents an `ORDER BY` clause.
Represents a field in the
ORDER BY clause.Represents how the
Sort.NullHandling option of an ORDER BY sort expression is to be evaluated.An
OrderByNullPrecedence implementation for databases conforming to the SQL standard which uses
NULLS FIRST and NULLS LAST in ORDER BY sort expressions to make null values appear before
or after non-null values in the result set.Representation of a
Row to be written through a INSERT or UPDATE statement.An
AbstractJdbcQuery implementation based on a PartTree.An
AbstractR2dbcQuery implementation based on a PartTree.Simple helper to be able to wire the
PersistentEntities from a R2dbcMappingContext bean available in
the application context.Deprecated, for removal: This API element is subject to removal in a future version.
use
AggregatePath insteadUtility to translate a
RelationalPersistentProperty into a corresponding property from a different
RelationalPersistentEntity by looking it up by name.An SQL dialect for Postgres.
An SQL dialect for Postgres.
Annotation to provide SQL statements that will get used for executing the method.
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.Maps
CriteriaDefinition and Sort objects considering mapping metadata and dialect-specific
conversion.Value object to represent a field and its meta-information.
Value object to represent a field and its meta-information.
Extension of
QueryMapper.Field to be backed with mapping metadata.Extension of
QueryMapper.Field to be backed with mapping metadata.Central R2DBC specific converter interface.
Value object to capture custom conversion.
R2DBC-specific extension to
Dialect.Interface specifying a basic set of reactive R2DBC operations using entities.
Implementation of
R2dbcEntityOperations.R2DBC-specific extension to
RelationalMappingContext.Reactive specific implementation of
QueryMethod.R2DBC specific
Repository interface with reactive support.Reactive
RepositoryConfigurationExtension for R2DBC.Factory to create
R2dbcRepository instances.FactoryBean to create
R2dbcRepository instances.Simple constant holder for a
SimpleTypeHolder enriched with R2DBC specific simple types.Reactive
EntityCallback to populate auditing related fields on an entity about to be saved.Deprecated.
Interface to retrieve parameters for named parameter processing.
The
ReactiveDeleteOperation interface allows creation and execution of DELETE operations in a fluent
API style.Required
filter.Table override (optional).
The
ReactiveDeleteOperation.ReactiveDelete interface provides methods for constructing DELETE operations in a fluent way.Trigger
DELETE operation by calling one of the terminating methods.The
ReactiveInsertOperation interface allows creation and execution of INSERT operations in a fluent
API style.Table override (optional).
The
ReactiveInsertOperation.ReactiveInsert interface provides methods for constructing INSERT operations in a fluent way.Trigger
INSERT execution by calling one of the terminating methods.The
ReactiveSelectOperation interface allows creation and execution of SELECT operations in a fluent
API style.The
ReactiveSelectOperation.ReactiveSelect interface provides methods for constructing SELECT operations in a fluent way.Result type override (optional).
Define a
Query used as the filter for the SELECT.Table override (optional).
Trigger
SELECT execution by calling one of the terminating methods.The
ReactiveUpdateOperation interface allows creation and execution of UPDATE operations in a fluent
API style.The
ReactiveUpdateOperation.ReactiveUpdate interface provides methods for constructing UPDATE operations in a fluent way.Trigger
UPDATE execution by calling one of the terminating methods.Table override (optional).
BeforeConvertCallback to capture auditing information on persisting and updating entities.A
RelationalConverter is responsible for converting for values to the native relational representation and
vice versa.Super class for events produced during deleting an aggregate.
Converts an entity that is about to be deleted into
DbActions inside a MutableAggregateChange that
need to be executed against the database to recreate the appropriate state in the database.Relational database-specific
EntityInformation.Converts an aggregate represented by its root into a
RootAggregateChange.Extension of
EntityMetadata to additionally expose the collection name an entity shall be persisted to.Converts an aggregate represented by its root into a
RootAggregateChange.Utilities commonly used to set/get properties for instances of RelationalPersistentEntities.
Converts an aggregate represented by its root into a
RootAggregateChange.an event signalling JDBC processing.
An event that is guaranteed to have an entity.
Relational-specific extension to
ManagedTypes.MappingContext implementation.Relational-specific
ParameterAccessor.Custom extension of
Parameters.Custom
Parameter implementation.Relational-specific
ParametersParameterAccessor.A
PersistentEntity interface with additional methods for JDBC/RDBMS related
metadata.A
PersistentProperty with methods for additional RDBMS related metadata based on columns.Implementation of
AbstractQueryCreator that creates a query from a PartTree.Events triggered during saving of an aggregate.
Resolves relations within an aggregate.
Render context providing
RenderNamingStrategy and other resources that are required during rendering.Factory for
RenderContext based on Dialect.Naming strategy for SQL rendering.
Represents the change happening to the aggregate (as used in the context of Domain Driven Design) as a whole.
Represents a tabular structure as document to enable hierarchical traversal of SQL results.
Wrapper value object for a
RowDocument to be able to access raw values by
RelationalPersistentProperty references.A
BatchingAggregateChange implementation for save changes that can contain actions for any mix of insert and
update operations.Delegate to run
scroll queries and create result Window.Delegate to handle
scroll queries and create result Window.Supertype of all Abstract Syntax Tree (AST) segments.
A list of
Segment instances.AST for a
SELECT statement.Entry point to construct a
Select statement.Interface exposing the
Select build method.Builder exposing
SELECT and FROM methods.Builder exposing
FROM methods.Builder exposing
FROM, JOIN, WHERE, LIMIT/OFFSET and LOCK methods.Builder exposing
FROM, WHERE, LIMIT/OFFSET, JOIN AND and LOCK continuation
methods.Builder exposing
FROM, JOIN, WHERE, LIMIT/OFFSET and LOCK methods.Interface exposing
JOIN methods.Limit/offset methods.
Lock methods.
Interface exposing
ON methods to declare JOIN relationships.Builder exposing JOIN and
JOIN … ON continuation methods.Interface declaring the target column comparison relationship.
Builder exposing
ORDER BY and LOCK methods.Interface exposing
WHERE, LOCK methods.Value object representing the select list (selected columns, functions).
Render context specifically for
SELECT statements.Simple function accepting one or more
Expressions.Default implementation of the
CrudRepository interface.Simple
ReactiveSortingRepository implementation using R2DBC through DatabaseClient.Default implementation of
RelationalEntityMetadata.A
SqlGenerator that creates SQL statements for loading complete aggregates with a single statement.Utility to create SQL
Segments.Generates SQL statements for loading aggregates.
Provides
SqlGenerators per domain type.Represents a named object that exists in the database like a table name or a column name.
Functional interface to sanitize SQL identifiers for SQL usage.
Creates the
SqlIdentifierParameterSource for various SQL operations, dialect identifier processing rules and
applicable converters.An SQL dialect for Microsoft SQL Server.
An SQL dialect for Microsoft SQL Server.
SQL-Server specific
SelectRenderContext.SqlSort supports additional to
Sort unsafe sort expressions.Custom
Sort.Order that keeps a flag to indicate unsafe property handling, i.e. the String provided is not
necessarily a property but can be an arbitrary expression piped into the query execution.Strategy interface for mapping a
RelationalPersistentProperty to a Database type.Entrypoint to build SQL statements.
Mapper for statement specifications to
PreparedOperation.DELETE specification.INSERT specification.SELECT specification.Extension to
StatementMapper that is associated with a type.UPDATE specification.A query to be executed based on a repository method, it's annotated SQL query and the arguments provided to the
method.
String-based
StringBasedR2dbcQuery implementation.Represents a
CharSequence literal.Baseclass for all kinds of "select in parenthesis".
Wrapper for a
Select query to be used as subselect.The annotation to configure the mapping from a class to a database table.
Represents a table reference within a SQL statement.
A segment that can be used as table in a query.
Simple condition that evaluates to SQL
TRUE.Signals failure to set the id property of an entity.
Class to easily construct SQL update assignments.
AST for aa
UPDATE statement.Entry point to construct an
Update statement.Interface exposing the
Update build method.Interface exposing
SET methods.Interface exposing
WHERE methods.A subclass of
QueryMapper that maps Update to update assignments.Represents a value function to return arbitrary values that can be escaped before returning the actual value.
VALUES clause.Interface for implementations that wish to be visited by a
Visitor.AST
Segment visitor.Where clause.RelationalEvent that represents a change to an aggregate and therefore has an AggregateChangeInterface for events which are guaranteed to have an entity.
Interface for
RelationalEvents which have an Identifier but might not have an entity.
MappingJdbcConverterinstead as the naming suggests a limited scope of functionality.