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.
Delegating RowMapper that reads a row into T and converts it afterwards into Object.
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
 
Condition representing an AND relation between two Conditions.
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.
Segment to select all columns from a Table.
Deprecated.
since 3.2, use MappingJdbcConverter instead as the naming suggests a limited scope of functionality.
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.
Value object representing a Condition with its 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.
Interface exposing AND/OR combinator methods for WHERE Conditions.
Represents a dialect that is implemented by a particular database.
Resolves a Dialect.
Resolves a R2dbcDialect from a ConnectionFactory using DialectResolver.R2dbcDialectProvider.
 
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 statement
In 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 Dialects
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.
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.
The annotation to configure the mapping for a List, Set or Map property in the database.
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.
Conversion context defining an interface for graph-traversal-based conversion of row documents.
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.
Simple singleton to convert Booleans to their Byte representation.
Simple singleton to convert Bytes to their Boolean representation.
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.
Condition representing an OR relation between two Conditions.
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 instead
Utility 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.
Query object representing Criteria, columns, Sort, and limit/offset for a SQL query.
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.
Configures a RowMapper for each type to be used for extracting entities of that type from a ResultSet.
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.
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.
since 1.2 in favor of using direct usage of StatementMapper, UpdateMapper and R2dbcConverter.
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.
Define a Query used as the filter for the Update.
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.
Transform an Example into a Query.
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.
SQL renderer for Select and Delete statements.
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.
Interface exposing AND/OR combinator methods for WHERE Conditions.
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.
SQL renderer for Select and Delete statements.
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.
Interface exposing AND/OR combinator methods for WHERE Conditions.
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 AggregateChange
Interface for events which are guaranteed to have an entity.
Interface for RelationalEvents which have an Identifier but might not have an entity.