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 mapping events of Spring Data Relational
Base class to implement domain class specific
ApplicationListener classes.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.
Deprecated.
Deprecated.
Use
AfterConvertEvent instead.An
EntityCallback that gets invoked after an aggregate was saved.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.
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.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.Update assignment to a
Column.Factory for common
Assignments.Assign a
Expression to a Column.RelationalConverter that uses a MappingContext to apply basic conversion of relational values to
property values.Extension to
BasicRelationalPersistentProperty.RelationalConverter that uses a MappingContext to apply basic conversion of relational values to
property values.Meta data about a property to be used by repository implementations.
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.
An
EntityCallback that gets invoked before an entity is deleted.Gets published when an entity is about to get deleted.
An
EntityCallback that gets invoked before changes are applied to the database, after the aggregate was
converted to a database change.Gets published before an entity gets saved to the database.
BETWEEN
Condition comparing between Expressions.Bind marker/parameter placeholder used to construct prepared statements with parameter substitution.
Represents a
Boolean literal.Delegates each methods 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.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 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 a merge statement for a single entity that is not the root of an aggregate.
Represents an update statement for a single entity that is not 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 that may "update" its entity.A
DbAction not operation on the root of an aggregate but on its contained entities.Exception thrown when during the execution of a
DbAction an exception gets thrown.The default
DataAccessStrategy is to generate SQL statements based on meta data 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.Delegates all method calls to an instance set after construction.
AST for a
DELETE statement.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.Converter to instantiate DTOs from fully equipped domain objects.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.
Maps a
ResultSet to an entity of type T, including entities referenced.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.FROM clause.Factory for common
function expressions.An SQL dialect for H2.
Converter converting from an H2 internal representation of a timestamp with time zone to an OffsetDateTime.
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 the how obtaining generated ids after an insert works for a given JDBC driver.
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.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
DialectsThis interface aggregates information about an Insert with default values statement.
INTO clause.IS NULL Condition.Specifies a 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.Db2Dialect that registers JDBC specific converters.Builder for
Identifier.MappingContext implementation for JDBC.Db2Dialect that registers JDBC specific converters.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.
Represents a literal.
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.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.
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.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.An SQL dialect for Oracle.
Represents an `ORDER BY` clause.
Represents a field in the
ORDER BY clause.An
AbstractJdbcQuery implementation based on a PartTree.A wrapper around a
PersistentPropertyPath for making common operations
available used in SQL generation and conversionAn SQL dialect for Postgres.
Annotation to provide SQL statements that will get used for executing the method.
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 an
MutableAggregateChange.Extension of
EntityMetadata to additionally expose the collection name an entity shall be persisted to.Converts an aggregate represented by its root into an
MutableAggregateChange.Utilities commonly used to set/get properties for instances of RelationalPersistentEntities.
Converts an aggregate represented by its root into an
MutableAggregateChange.an event signalling JDBC processing.
An event that is guaranteed to have an entity.
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 JDBC/RDBMS related meta data.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.
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.Deprecated.
since 2.2.5 use
Comparison instead.Simple function accepting one or more
Expressions.Default implementation of the
CrudRepository interface.Default implementation of
RelationalEntityMetadata.Utility to create SQL
Segments.Provides
SqlGenerators per domain type.Represents a named object that exists in the database like a table name or a column name.
An SQL dialect for Microsoft SQL Server.
SQL-Server specific
SelectRenderContext.Entrypoint to build SQL statements.
A query to be executed based on a repository method, it's annotated SQL query and the arguments provided to the
method.
Represents a
CharSequence literal.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.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.
AfterConvertCallbackinstead.