All Classes and Interfaces

Class
Description
Abstract asynchronous interceptor implementation.
Abstract async specification interceptor.
The abstract connection operations.
Delegating ConversionContext.
Abstract asynchronous interceptor implementation with a result conversion.
Abstract asynchronous interceptor implementation with a result conversion.
Abstract CriteriaBuilder implementation.
Abstract criteria matcher.
Abstract transaction manager condition.
Abstract default transaction operations.
Abstract Hibernate operations shared between the synchronous and the reactive implementations.
The abstract internal transaction.
MongoDB's collections creator.
The abstract numerical persistent property expression.
Abstract pattern method match that support two variations of method names.
Abstract version of the PersistentEntity interface.
The abstract implementation of PersistentEntityCriteriaDelete.
The abstract implementation of PersistentEntityCriteriaQuery.
The abstract implementation of PersistentEntityCriteriaUpdate.
The abstract implementation of PersistentEntityFrom.
The abstract persistent property expression.
The abstract implementation of PersistentPropertyPath.
Abstract predicate represented by a property path.
Abstract predicate implementation.
The matcher based on a simple patter.
Abstract implementation of PreparedDataOperation.
Abstract transaction operations that propagates the status in the propagated context.
Publisher interceptor.
Abstract interceptor that executes a Query.
Abstract reactive entities operations.
Abstract reactive entity operations.
Abstract reactive repository interceptor.
Abstract reactive specification interceptor.
The reactive MongoDB connection operations implementation.
Abstract Reactor transaction operations.
Represents the current reactive transaction status.
Abstract repository implementation.
Abstract specification interceptor.
Abstract specification interceptor.
Abstract specification interceptor.
 
Abstract superclass for specification methods.
Adds Spring Transaction management capability to Micronaut Data.
An abstract class for builders that build SQL-like queries.
A criterion context.
A criterion handler.
Represents a placeholder in query.
 
Abstract SQL repository implementation not specifically bound to JDBC.
Functional interface used to supply a statement.
Abstract synchronous entities operations.
Abstract synchronous entity operations.
Abstract transaction operations.
The aggregate expression.
The aggregate type.
The aliased selection.
Event listener that allows invoking methods defined on entities and annotated with an event annotation such as PrePersist.
A property that represents an association.
Extends a query and allows querying an association.
Internal association utilities.
A RepositoryOperations capable of supporting asynchronous access.
An interface for async connection manager.
Asynchronous variation of CrudRepository.
An implementation of AsyncRepositoryOperations that delegates to a reactive operation.
Interface representing async version of JpaSpecificationExecutor.
A repository that supports pagination.
Asynchronous operations for reading data from a backing implementations.
An interface for async transaction management.
Status object for async transactions.
Implementation of the asynchronous connection operations using a reactive connection operations.
Implementation of the asynchronous transaction manager using a reactive transaction manager.
Implementation of the asynchronous transaction manager using a synchronous transaction manager.
The attribute converter is used for converting mapped entity value to the persisted value and back.
Intended to support different implementation of attribute converters like JPA's 'jakarta.persistence.AttributeConverter'.
Attribute converter registry.
Meta annotation to identity annotations that are auto-populated by the Micronaut Data.
Abstract implementation of a listener that handles AutoPopulated.
An event listener that handles DateCreated and DateUpdated.
The basic implementation of StoredQuery.
A batch operation is an operation performed on one or more entities of the same type.
A TypeMapper that maps objects using a compile time computed BeanIntrospection.
Bindable parameters version of PreparedQuery.
Bindable parameters version of StoredQuery.
Parameters binder.
The query binding parameter.
The binding context.
Implementation of RepositoryOperations that blocks every call from ReactorReactiveRepositoryOperations.
Implementation of RepositoryOperations that blocks every call from ReactorReactiveRepositoryOperations.
Exception thrown when a transaction can't be created using an underlying transaction API such as JTA.
Exception thrown when a JDBC connection cannot be retrieved.
Exception thrown when a JDBC connection cannot be retrieved.
Maps JPA column annotation to MappedProperty.
Maps JPA column annotation to MappedProperty.
Implementation of ResultReader for R2DBC.
A reader that uses the column index.
Implementation of ResultReader for R2DBC.
A ResultReader for JDBC that uses the column name.
Inspired by Hibernate's annotation of the same name.
The compound selection.
The conjunction predicate implementation.
The annotation is similar to "jakarta.transaction.Transactional", allowing to create a new data source connection.
Default Connectable interceptor.
SQL callback interface that helps with handling SQLException.
Resolves the tenant data source name for the connection manager.
The connection definition.
Possible propagation values.
Generic connection exception super class.
The synchronous connection operations interface.
The registry of various connection operations managers.
The connection status.
Interface for the connection synchronization callbacks.
The constants needed for Cosmos DB implementation.
Contextual aware data source implementation.
Allows injecting a Connection instance as a bean with any methods invoked on the connection being delegated to connection bound to the current context connection.
An interceptor that allows injecting a Connection that acts a proxy to lookup the connection for the current transaction.
Allows injecting a ClientSession instance as a bean with any methods invoked on the connection being delegated to connection bound to the current transaction.
Maps JPA Convert annotation.
Maps JPA Convert annotation.
Maps JPA converter annotation to a singleton instance.
Maps JPA converter annotation to a singleton instance.
Cosmos Db data access exception.
The Azure Cosmos database configuration.
The settings for Cosmos container.
Throughput settings for container.
Throughput settings for database.
The Cosmos diagnostics processor interface.
Model holding cosmos entity fields like container name, partition key, version field.
Stereotype repository that configures a Repository as a CosmosRepository.
Azure Cosmos repository operations.
The Azure Cosmos DB sql query builder.
The utility class for Cosmos operations, currently used for diagnostic processing and error handling.
An interceptor that executes a a count of all records asynchronously.
Interceptor that supports async count specifications.
An interceptor that executes a a count of all records.
Count method match.
An interceptor that executes a count query reactively and returns a reactive type that emits a single result as a RxJava Single or a Reactor Mono.
Interceptor that supports reactive count specifications.
Interceptor that supports count specifications.
Interceptor that supports count specifications.
Interceptor that supports Spring Data JPA specifications.
Implementation of count(Specification) for JPA specifications.
Interface used for the construction of queries at compilation time an implementation may optionally provide an implementation of this at runtime.
Delete query criteria builder specification.
Query criteria builder specification.
Update query criteria builder specification.
Criteria util class.
A repository interface for performing CRUD (Create, Read, Update, Delete).
Default implementation of DateTimeProvider.
Custom converter deserializer.
Custom converter serializer.
Parent class for data access related exceptions that occur at runtime.
Exception thrown when the underlying resource fails to connect.
The util class for annotations for micronaut-data module.
General data configuration.
Configuration for pageable.
The type of ConversionService that also include the Data project only registered converters.
Marker interface for all Data related interceptors.
The root Data introduction advice, which simply delegates to an appropriate interceptor declared in the io.micronaut.data.intercept package.
Configuration for Data JDBC.
Internal annotation used to configure execution handling for io.micronaut.data.runtime.intercept.DataIntroductionAdvice.
Describes the operation type.
Internal annotation representing query parameter binding.
Configuration for Schema generation.
Parent configuration interface.
Multi-tenancy mode MultiTenancyMode.DATASOURCE condition.
The tenant resolver for multi-tenancy mode DATASOURCE.
The DataSource transaction manager.
Configures a DataSourceTransactionManager for each configured JDBC DataSource.
Generic version of allowing transformations to be applied when reading or writing data to and from the a database.
Enum of basic data types allowing compile time computation which can then subsequently be used at runtime for fast switching.
Micronaut Data specific TypeConverter that should be integrated into DataConversionService.
Can be applied to date type to indicate the property should be populated when it is first inserted.
Used by Micronaut Data to assign a time stamp to entity fields labeled with DateCreated or DateUpdated.
Can be applied to date type to indicate the property should be populated when it was last updated.
Default implementation of the ConnectionDefinition interface.
The default connection status.
Default implementation of CountAsyncInterceptor.
Default implementation of CountInterceptor.
Default implementation of CountReactiveInterceptor.
The DataSource connection operations.
Default implementation of DeleteAllAsyncInterceptor.
Default implementation of DeleteAllInterceptor.
Default implementation of DeleteAllReactiveInterceptor.
The default implementation of DeleteOneAsyncInterceptor.
The default implementation of DeleteOneInterceptor.
Default implementation of DeleteOneReactiveInterceptor.
Default implementation of the EntityEventContext interface.
The default implementation of ExistsByAsyncInterceptor.
The default implementation of ExistsByInterceptor.
Default implementation of ExistsByReactiveInterceptor.
The default implementation of FindAllAsyncInterceptor.
The default implementation of FindAllInterceptor.
Default implementation of FindAllReactiveInterceptor.
Default implementation that handles lookup by ID asynchronously.
Default implementation that handles lookup by ID.
Default implementation of FindByIdReactiveInterceptor.
Default implementation of the FindOneAsyncInterceptor interface.
Default implementation of the FindOneInterceptor interface.
Default implementation of FindOneReactiveInterceptor.
Default implementation of FindOptionalInterceptor.
Default implementation of FindPageAsyncInterceptor.
Default implementation of FindPageInterceptor.
Default implementation of FindPageReactiveInterceptor.
Default implementation of FindSliceAsyncInterceptor.
Default implementation of FindSliceInterceptor.
Default implementation of FindSliceReactiveInterceptor.
Default implementation of FindStreamInterceptor.
Implementation of JdbcRepositoryOperations.
 
Default implementation of MongoCollectionNameProvider.
Internal implementation of MongoDatabaseNameProvider.
Default implementation of PagedQuery.
Default paged query resolver.
The default PhysicalNamingStrategy to use.
Represents a prepared query.
Default prepared query resolver.
Models a query that can be executed against a data store.
The reactive R2DBC connection operations implementation.
The reactive Cosmos DB repository operations implementation.
The reactive MongoDB repository operations implementation.
 
Default implementation of SaveAllAsyncInterceptor.
Default implementation of SaveAllInterceptor.
Default implementation of SaveAllReactiveInterceptor.
Default implementation of SaveEntityAsyncInterceptor.
Default implementation of SaveEntityInterceptor.
Default implementation of SaveEntityReactiveInterceptor.
Default implementation of SaveOneAsyncInterceptor.
Default implementation of SaveOneInterceptor.
Default implementation of SaveOneReactiveInterceptor.
Implementation of SqlPreparedQuery.
Implementation of SqlStoredQuery.
Used as a super class to resolve and potentially cache data about a method.
Represents a prepared query.
Default stored query resolver.
Adds support for MicronautTest transactional handling.
Default implementation of the TransactionDefinition interface, offering bean-style configuration and sensible default values (PROPAGATION_REQUIRED, ISOLATION_DEFAULT, TIMEOUT_DEFAULT, readOnly=false).
The default transaction status.
Default implementation of UpdateAllEntriesAsyncInterceptor.
Default implementation of UpdateAllEntitiesInterceptor.
Default implementation of UpdateAllEntitiesReactiveInterceptor.
Default implementation of UpdateAsyncInterceptor.
Default implementation of UpdateEntityAsyncInterceptor.
Default implementation of UpdateEntityInterceptor.
Default implementation of UpdateEntityReactiveInterceptor.
Default implementation of UpdateInterceptor.
Default implementation of UpdateReactiveInterceptor.
Delegate implementation of PreparedQuery.
Delegate implementation of StoredQuery.
JDBC DataSource implementation that delegates all calls to a given target DataSource.
Unwraps transactional data source proxies.
An interceptor that executes a batch delete of all records asynchronously.
Implementation of async deleteAll(Specification).
An interceptor that executes a batch delete.
An interceptor that executes a batch delete reactively.
Implementation of reactive deleteAll(Specification).
Implementation of deleteAll(Specification).
Delete all specification method.
A delete batch operation is an operation performed on one or more entities of the same type.
Delete criteria method match.
Count method matcher.
An interceptor that executes a delete os a single record asynchronously.
Interceptor that deletes a single entity.
An interceptor that executes a single delete reactively.
A delete operation that updates the given entity.
Criteria delete specification.
Interceptor that supports delete specifications.
Interceptor that supports Spring Data JPA specifications.
Delete specification method.
The SQL dialect to use.
Multi-tenancy mode MultiTenancyMode.DISCRIMINATOR condition.
The disjunction predicate implementation.
Requires the repository to be processed by the data-document-processor.
A BeanIntrospectionMapper that reads the result using the specified PersistentEntity and ResultReader and using the BeanIntrospectionMapper.map(Object, Class) allows mapping a result to a introspected Data Transfer Object (DTO).
The dummy prepared statement, that allows creating StoredQuery without actual prepared statement.
Annotation to be used on POJOs that are embeddable in MappedEntity types.
Maps JPA Embeddable to Micronaut Data Embedabble.
Maps JPA Embeddable to Micronaut Data Embedabble.
Serdeable mapper of Embeddable.
A visitor that handles types annotated with Embeddable.
An embedded association.
Maps JPA Embedded to Micronaut Data embedded.
Maps JPA Embedded to Micronaut Data embedded.
Annotation that specifies the embedded ID.
Maps JPA's embedded ID to EmbeddedId.
Maps JPA's embedded ID to EmbeddedId.
Exception thrown if a query produces no result and the result type is not nullable.
Translates the jakarta.persistence annotation model into the generic model understood by Micronaut Data.
Translates the javax.persistence annotation model into the generic model understood by Micronaut Data.
Context object for event receivers.
The interface representing an entity event listener.
Marker annotation of entity lifecycle event handler.
Primary implementation of the EntityEventListener interface that aggregates all other listeners.
Validates entity event method signatures.
Allows configuring JPA 3.0 entity graphs on query methods.
An entity operation with an instance.
An operation on an entity type.
The entity operations container.
Defines entity representation for database operations.
The column type.
Supported entity representation types.
Maps JPA's @Enumerated to a correct type def.
Maps JPA's @Enumerated to a correct type def.
Field annotation indicating that entity field should be used as a document version or _etag in Azure Cosmos Db.
Integrates event handling.
Exception utils.
An implementation of AsyncRepositoryOperations that delegates to a blocking operations and specified Executor.
An implementation of ReactiveRepositoryOperations that delegates to a blocking operations and specified Executor.
Interceptor that supports async exists specifications.
An interceptor that executes a query to check for existence.
An interceptor that checks for the existence of a record.
An interceptor that executes an existence query reactively.
Exists method matcher.
Interceptor that supports reactive exists specifications.
Interceptor that supports exists specifications.
Exists specification method.
Marks parameter as expandable, which means that the query will be altered during runtime to accommodate additional values.
The expression binary operation predicate implementation.
An interceptor that executes a query and returns an iterable result asynchronously.
Implementation of async unpaged version of findAll(Specification).
An interceptor that doesn't execute a query but instead just lists all the results.
An interceptor that executes a Query and a Publisher that emits the result objects reactively.
Implementation of reactive unpaged version of findAll(Specification).
Implementation of the unpaged version of findAll(Specification).
Implementation of the unpaged version of findAll(Specification).
Implementation of the unpaged version of findAll(Specification).
Find all specification method.
An interceptor that executes a query and returns a result asynchronously.
An interceptor that finds an entity by ID.
An interceptor that executes an find by id reactively.
Finders utils.
Internally used for dynamically defining a class element.
The interceptor match.
The custom find method interceptor definition.
Teh find interceptor definition.
Find method matcher.
An interceptor that executes a query and returns a result asynchronously.
Implementation of async findOne(Specification).
An interceptor that executes a Query and returns a single entity result.
An interceptor that executes a query reactively and returns a reactive type that emits a single result as a RxJava Single or a Reactor Mono.
Implementation of async findOne(Specification).
Implementation of findOne(Specification) for JPA specifications.
Implementation of findOne(Specification) for JPA specifications.
Implementation of findOne(Specification) for Spring Data JPA specifications.
JPA specification findOne.
An interceptor that executes a Query and returns an optional single entity result.
An interceptor that executes a query and returns a Page asynchronously.
Runtime implementation of CompletableFuture<Page> find(Specification, Pageable).
An interceptor that handles a return type of Page.
An interceptor that finds a page reactively.
Runtime implementation of Publisher<Page> find(Specification, Pageable).
Runtime implementation of Page find(Specification, Pageable).
Runtime implementation of Page find(Specification, Pageable).
Runtime implementation of Page find(Specification, Pageable) for Spring Data JPA.
Compilation time implementation of Page find(Specification, Pageable) for JPA.
An interceptor that executes a query and returns a Slice asynchronously.
An interceptor that handles a return type of Slice.
An interceptor that finds a slice reactively.
An interceptor that executes a Query and returns a Stream of results.
Interceptor for flushing.
Designates a property as a generated value.
The type of generation.
Maps JPA's generated value to Micronaut's.
Maps JPA's generated value to Micronaut's.
Parent repository interface for all repositories.
Exception that represents a transaction failure caused by a heuristic decision on the side of the transaction coordinator.
Possible state outcomes.
The connection operations that extract Connection from Hibernate Session.
The Hibernate connection operations.
Hibernate reactive condition.
Hibernate reactive repository operations.
Hibernate sync condition.
The Hibernate transaction manager.
Sets up the default hibernate transaction manager.
Hints capable repository interface.
Designates a field or method that is annotated with the Id of an entity.
Maps JPA's Id annotation to Micronaut's.
Maps JPA's Id annotation to Micronaut's.
ID deserializer.
The ID expression implementation.
ID property naming strategy.
ID serializer.
The internal implementation of Expression.
The IgnoreWhere annotation prevents the generation of additional criteria for this query.
Exception thrown when the existence or non-existence of a transaction amounts to an illegal state according to the transaction propagation behavior that applies.
Designates one of the indexes part of the indexes member within an Table annotation.
Maps JPA's Index annotation to Micronaut's.
Maps JPA's Index annotation to Micronaut's.
Repeatable annotation for Index.
An insert batch operation is an operation performed on one or more entities of the same type.
An insert operation that inserts a record.
The internal transaction representation.
Exception that gets thrown when an invalid isolation level is specified, i.e.
Exception that gets thrown when an invalid timeout is specified, that is, the specified timeout valid is out of range or the transaction manager implementation doesn't support timeouts.
The internal implementation of IPredicate.
The internal implementation of Selection.
An interceptor that returns an iterable result.
Maps JTA's Jakarta transaction annotation.
JDBC connection utils.
Conversion context for JDBC implementation.
Simple JDBC operations interface.
Stereotype repository that configures a Repository as a JdbcRepository using raw SQL encoding and JdbcRepositoryOperations as the runtime engine.
Sub-interface for RepositoryOperations specific to JDBC implementations.
JDBC schema handler.
A @Join defines how a join for a particular association path should be generated.
The type of join.
Subset of the JPA join column annotation.
Maps JPA's JoinColumn annotation to Micronaut's.
Maps JPA's JoinColumn annotation to Micronaut's.
The repeatable container of @JoinColumn.
Traversing the query selection and predicates and extracting required query joins.
The data structure representing a join.
A join path represents a path, association and join type for performing a join with a query.
Repeatable annotation for Join.
Subset of the JPA join table annotation allowing support for bidirectional and unidirectional one-to-many join fetches only.
Maps JPA's JoinTable annotation to Micronaut's.
Maps JPA's JoinTable annotation to Micronaut's.
Builds JPA 1.0 String-based queries from the Query model.
Simple composed repository interface that includes CrudRepository and PageableRepository.
Operations interface specific to JPA.
Interface to allow execution of Specifications based on the JPA criteria API.
Interface to allow execution of query/delete/update methods using dynamic JPA criteria API.
The wrapper around JsonMapper to read JSON values from the result set.
Enum of JSON data type representations or actually storage types.
The JSON query result mapper.
The custom annotation used for DataType.JSON fields that can help us determing how to store and retrieve json fields.
The annotation defining Json Duality View.
Maps JTA's transaction annotation.
List method matcher.
The literal expression implementation.
Interceptor for Load.
Many relation serializer.
Maps JPA's ManyToMany annotation to Relation.
Maps JPA's ManyToMany annotation to Relation.
Maps JPA's ManyToOne annotation to Relation.
Maps JPA's ManyToOne annotation to Relation.
Serdeable mapper of Id.
Designates a class as being persisted.
Serdeable mapper of MappedEntity.
Configurations bean introspection correctly for each entity.
A TypeElementVisitor that pre-computes mappings to columns based on the configured naming strategy.
Serdeable mapper of Id.
Designates a method or field that is mapped as a persistent property.
Serdeable mapper of MappedProperty.
Serdeable mapper of Relation.
A mapping exception is one thrown if an issue exists at runtime or build time in the data mapping.
A match context when matching methods.
Immediate match fail.
Interceptor for JPA merge operation.
Implementation of dynamic finders.
Special version of stored query decorator that is aware of the method invocation context.
A match context for finding a matching method.
The method matcher.
Method match implementation.
The method info.
The internal source implementation of SourcePersistentEntityCriteriaBuilder that supports mapping method parameters.
Implementation of Hibernate 3.1's CurrentSessionContext interface that delegates to ConnectionOperations for providing a current Session.
Defines a custom MongoDB aggregate query options.
Defines a custom MongoDB query for aggregating results.
The MongoDB's aggregation command.
The MongoDB's aggregation options.
Mongo annotations constants.
Defines a custom MongoDB's collation.
The MongoDB collection name provider.
MongoDB's collections creator.
Mongo connection operations.
MongoDB database name provider.
Micronaut Data MongoDB integration configuration.
The driver type.
Not reactive driver condition.
Not sync driver condition.
The MongoDB's delete many command.
Defines a custom MongoDB delete query options.
Defines a custom MongoDB delete query.
Finder with `MongoQueryExecutor` repository implementation.
Defines a custom MongoDB filter query.
The MongoDB's find command.
Defines a custom MongoDB find query options.
The MongoDB's find options.
Defines a custom MongoDB query for finding results.
Mongo internal utils for building options.
MongoDB's PreparedQuery.
Defines a custom MongoDB's fields projection.
The Mongo query builder.
MongoDB specific repository that allows to use direct BSON objects.
Finder with custom defied query used to return a single result.
MongoDB's reactive collections creator.
MongoDB reactive repository operations.
Mongo reactive connection operations.
Mongo Reactor connection operations.
A variation of MongoReactiveRepositoryOperations with Reactor specific method to execute an operation with the contextual ClientSession.
Stereotype repository that configures a Repository as a MongoRepository.
Mongo DB repository operations.
Mongo parameter roles contansts.
Defines a custom MongoDB's sort.
MongoDB's StoredQuery.
Mongo transactional operations.
The MongoDB's many command.
Defines a custom MongoDB update query options.
Defines a custom MongoDB update query.
Mongo internal utils.
The multi-tenancy configuration.
The multi-tenancy mode.
Naming strategy enum for when a class or property name has no explicit mapping.
Example: foo-bar.
Example: foobar.
No naming conversion.
Example: foo_bar.
Example: FOO_BAR.
Example: foobar.
Override default naming strategy.
A strategy interface for resolving the mapped name of an entity or property.
The negated predicate implementation.
Exception thrown when attempting to work with a nested transaction but nested transactions are not supported by the underlying backend.
Exception that occurs if no connection is present.
The exception represents the error state when one result has been requested by data layer returned multiple results.
Exception that occurs if no transaction is present.
One relation deserializer.
One relation serializer.
Maps JPA's OneToMany annotation to Relation.
Maps JPA's OneToMany annotation to Relation.
Maps JPA's OneToOne annotation to Relation.
Maps JPA's OneToOne annotation to Relation.
The operation context.
Thrown when an optimistic locking conflict occurs.
Inspired by the Spring Data's Page and GORM's PagedResultList, this models a type that supports pagination operations.
Models pageable data.
A repository that supports pagination.
A request argument binder for binding a Pageable object from the request.
Object passed to queries for pagination requests.
Paged query resolver.
The abstract implementation of ParameterExpression.
Field annotation indicating that entity field should be used as partition key.
Context object for event receivers.
Exception that is thrown during event processing.
The persistent entity association path.
The association path representation.
The persistent entity association path.
Shared interface for a persistent element whether it be a type or a property.
Models a persistent entity and provides an API that can be used both within the compiler and at runtime.
The PersistentEntity aware query.
The persistent entity collection Join.
The persistent entity criteria builder.
The persistent entity CriteriaDelete.
The persistent entity CriteriaQuery.
The persistent entity CriteriaUpdate.
The persistent entity From.
The persistent entity Join.
The persistent entity list Join.
The persistent entity Path.
The persistent entity Root.
The persistent entity set Join.
Persistent entity utils.
The persistent entity association path.
Models a persistent property.
The property between predicate implementation.
The property binary operation predicate implementation.
The property IN predicate implementation.
The property IN value predicate implementation.
The implementation of Order.
The persistent property Path.
The property path representation.
The property unary operation predicate implementation.
The persistent entity association path.
Designates method that is representing a post load event listener.
Maps JPA's PostLoad annotation to Micronaut's.
Maps JPA's PostLoad annotation to Micronaut's.
Designates method that is representing a post persist event listener.
Maps JPA's PostPersist annotation to Micronaut's.
Maps JPA's PostPersist annotation to Micronaut's.
Functional version or PostPersist event handlers.
Designates method that is representing a post remove event listener.
Maps JPA's PostRemove annotation to Micronaut's.
Maps JPA's PostRemove annotation to Micronaut's.
Functional version or PostRemove event handlers.
Designates method that is representing a post update event listener.
Maps JPA's PostUpdate annotation to Micronaut's.
Maps JPA's PostUpdate annotation to Micronaut's.
Functional version or PostUpdate event handlers.
Predicate binary operations.
The predicate specification.
Predicate unary operations.
The visitable predicate.
The predicate visitor.
An operation that has been prepared for execution with the current context.
Interface that models a prepared query.
Prepared query decorator.
Prepared query resolver.
SQL PreparedStatement callback interface that helps with dealing with SQLException.
Designates method that is representing a pre persist event listener.
Maps JPA's PrePersist annotation to Micronaut's.
Maps JPA's PrePersist annotation to Micronaut's.
Functional version or PrePersist event handlers.
Designates method that is representing a post remove event listener.
Maps JPA's PreRemove annotation to Micronaut's.
Maps JPA's PreRemove annotation to Micronaut's.
Functional version or PreRemove event handlers.
Designates method that is representing a pre update event listener.
Maps JPA's PreUpdate annotation to Micronaut's.
Maps JPA's PreUpdate annotation to Micronaut's.
Functional version or PreUpdate event handlers.
In the case of having two operations active (for example when using JPA and JDBC at the same time) this interface is used as a marker to decide on the primary operations to lookup.
Models a list of projections.
Projections used to customize the results of a query.
Projections.
The AVG projection.
The MAX projection.
The MIN projection.
The SUM projection.
The interface allows automatically populating new values, potentially based on the previous value for AutoPopulated properties.
Defines the query string such as SQL, JPA-QL, Cypher etc that should be executed.
An interface capable of encoding a query into a string and a set of named parameters.
Query criteria method match.
Event context for when a query is performed.
Provides a query hint to the underlying query implementation.
Repeatable wrapper for QueryHint.
Main interface for constructing queries at either compilation or runtime.
Criterion used to restrict the results based on belonging to an array.
Computes the average value of a property.
Criterion used to restrict the result to be between values (range query).
A Criterion used to combine to criterion in a logical AND.
Criterion used to restrict the results based on a result containing the given value.
Projection to count distinct property names.
Used to count the results of a query.
Represents a criterion to be used in a criteria query.
A Criterion used to combine to criterion in a logical OR.
Distinct result projection.
Criterion used to restrict the results based on starting with a given value.
A criterion that restricts the results based on equality.
Restricts a value to be equal to all the given values.
A criterion for one property equaling another.
Used for exists subquery.
Used to restrict a value to be greater than the given value.
Restricts a value to be greater than all the given values.
Used to restrict a value to be greater than or equal to the given value.
Restricts a value to be greater than or equal to all the given values.
A criterion for one property being greater than or equal to another.
Restricts a value to be greater than some of the given values.
A criterion for one property being greater than another.
Restricts a value to be greater than some of the given values.
Group by property projection.
A criterion that restricts the results based on the equality of the identifier.
A projection used to obtain the identifier of an object.
Criterion used to restrict the results based on a pattern (likeness).
Criterion used to restrict the results based on a list of values.
Restricts a property to be empty (such as a blank string).
Restricts a property to be false.
Restricts a property to be empty (such as a blank string).
Restricts a property to be not null.
Restricts a property to be null.
Restricts a property to be true.
base class for a junction (AND or OR or NOT).
Used to restrict a value to be less than the given value.
Restricts a value to be less than all the given values.
Used to restrict a value to be less than the given value.
Restricts a value to be less than or equal to all the given values.
A criterion for one property being less than or equal to another.
Restricts a value to be less than some of the given values.
A criterion for one property being less than another.
Restricts a value to be less than some of the given values.
Criterion used to restrict the results based on a pattern (likeness).
A projection of a simple literal.
Computes the pageSize value of a property.
Computes the min value of a property.
A criterion used to negate several other criterion.
A criterion that restricts the results based on equality.
Restricts a value to be not equal to all the given values.
A criterion for one property not equaling another.
Used for exists subquery.
Criterion used to restrict the results based on a list of values.
A projection.
A Criterion that compares to properties.
Criterion that applies to a property and value.
A Criterion that applies to a property.
A projection that obtains the value of a property of an entity.
Criterion used to restrict the results based on a regex pattern.
Criterion used to restrict the results based on a regular expression pattern.
Size equals criterion.
Size greater than criterion.
Size greater than equals criterion.
Size less than criterion.
Size less than equals criterion.
Size not equals criterion.
Criterion used to restrict the results based on starting with a given value.
Used to differentiate criterion that require a subquery.
Computes the sum of a property.
A criterion that restricts the results based on the equality of the version.
The query model provider.
The predicate visitor to convert criteria predicates to QueryModel.
The selection visitor to convert criteria selection to QueryModel.
A parameter to a query.
Query parameter binding, represents the data needed to bind a property to the query parameter.
The query parameter binding.
Defines query result for database query execution.
Used to represent a built query that is computed at compilation time.
Supported query result types.
The information about query result info for the query method.
The query provider.
The basic StoredQuery created from QueryResult.
Criteria query specification.
An abstract interface over prepared statements.
Conversion context for R2DBC implementation.
Operations for R2DBC.
Implementation of QueryStatement for R2DBC.
R2DBC transaction operations.
Stereotype repository that configures a Repository as a R2dbcRepository using raw SQL encoding and R2dbcRepositoryOperations as the runtime engine.
An interface for R2DBC repository operations.
Schema generation for R2DBC.
The schema handler for R2DBC.
Finder with custom defied query used to return a single result.
Extends RepositoryOperations and adds the able for a datastore to expose reactive operations if they are supported.
Reactive cascade operations.
The cascade operations helper.
Interceptor that supports count specifications.
The reactive entities operations container.
The reactive entity operations container.
Implementation of the unpaged version of findAll(Specification).
Implementation of findOne(Specification) for JPA specifications.
Runtime implementation of Page find(Specification, Pageable).
Reactive operations for reading data from a backing implementations.
An interface fo reactive connection management.
Interface for CRUD using Reactive Streams.
Interface to allow execution of Specifications based on the JPA criteria API.
Interface representing reactive streams version of JpaSpecificationExecutor.
A repository that supports pagination.
An interface fo reactive transaction management.
A transactional callback interface.
Status object for reactive transactions.
Special version of ReactiveStreamsConnectionOperations that is exposing Reactor publishers.
CRUD repository for Project Reactor.
Interface to allow execution of Specifications based on the JPA criteria API.
Interface representing Reactor version of JpaSpecificationExecutor.
A repository that supports pagination.
The version of ReactiveRepositoryOperations which exposes reactor publisher types.
The version of ReactiveRepositoryOperations which exposes reactor publisher types.
Special version of ReactiveTransactionOperations that is exposing Reactor publishers.
An implementation of AsyncRepositoryOperations that delegates to a reactive operation.
Stereotype annotation for demarcating a read-only transaction.
Annotation used to indicate a field or method is a relation to another type.
Cascade type handling for different associations.
The relation kind.
Designates a type of a data repository.
Models compilation time configuration for the repository.
Key used to cache results for repository method invocations.
Common interface for repository implementations to implement.
The registry of RepositoryOperations.
The main TypeElementVisitor that visits interfaces annotated with Repository and generates queries for each abstract method.
Requires configuration that defines reactive Hibernate to be used.
Requires configuration that defines reactive Mongo driver to be used.
Requires configuration that defines sync Hibernate to be used.
Requires configuration that defines sync Mongo driver to be used.
Factory for creating criterion instances.
Restrictions.
Restrictions.After<T extends Comparable<? super T>>
Restrictions.Before<T extends Comparable<? super T>>
Array contains restriction.
Between restriction.
Collection contains restriction.
Contains with criterion.
Contains with criterion.
Contains with criterion.
Contains with criterion IgnoreCase.
Ends with criterion.
Ends with criterion.
Ends with criterion.
Ends with criterion.
Equal restriction.
Equals restriction.
Greater than expression.
Greater than equals.
Ids restriction.
Case insensitive like.
In restriction.
InList restriction.
InRange restriction.
IsEmpty restriction.
IsFalse restriction.
IsNotEmpty restriction.
IsNotNull restriction.
IsNull restriction.
IsTrue restriction.
Less than.
Less than equals.
Like criterion.
PropertyNotEqual restriction.
PropertyNotEquals restriction.
NotIn restriction.
NotInList restriction.
Regex criterion.
Property restriction.
Regex like.
Starts with criterion.
Starts with criterion.
Starts with criterion.
Starts with criterion.
EqualIgnoreCase restriction.
EqualsIgnoreCase restriction.
Restriction.
A mapping function can be used as a method parameter to repository methods to allow custom mapping of results.
A context object that simplifies mapping results to objects.
A result reader is a type that is capable of reading data from the given result set type.
A runtime representation of Association.
The runtime implementation of AbstractCriteriaBuilder.
A registry for looking up entities across repositories.
Runtime implementation of PersistentEntity that uses pre-computed Introspected bean data and is completely stateless.
A runtime representation of PersistentProperty.
Conversion context that has access to converter RuntimePersistentProperty.
Interface for CRUD using RxJava 2.
An interceptor that saves multiple entities asynchronously.
Interface for the interceptor that handles saving a list or iterable of objects.
An interceptor that saves a number of entities reactively.
An interceptor that saves a single entity asynchronously.
An interceptor that accepts a single entity to be saved and returns either the entity or nothing.
A save method for saving a single entity.
An interceptor that saves a single entity reactively.
An interceptor that saves a single entity asynchronously.
An interceptor that accepts a single entity to be saved and returns either the entity or nothing.
A save method for saving a single entity.
An interceptor that saves a single entity reactively.
Interface that specifies an API to programmatically manage transaction savepoints in a generic fashion.
Enum describing how to handle the schema at startup.
Schema generator used for testing purposes.
Multi-tenancy mode MultiTenancyMode.SCHEMA condition.
The tenant resolver for multi-tenancy mode SCHEMA.
The visitable selection.
The selection visitor.
Inspired by the Spring Data's Slice and GORM's PagedResultList, this models a type that supports pagination operations.
An interface for objects that can be sorted.
The ordering of results.
Represents the direction of the ordering.
Source code level implementation of Association.
The internal source implementation of ParameterExpressionImpl.
An implementation of PersistentEntity that operates on the sources.
The source persistent entity extension of PersistentEntityCriteriaBuilder.
The source implementation of SourcePersistentEntityCriteriaBuilder.
The source persistent entity extension of PersistentEntityCriteriaDelete.
The source persistent entity extension of PersistentEntityCriteriaQuery.
The source persistent entity extension of PersistentEntityCriteriaUpdate.
Source code level implementation of PersistentProperty.
Specification in the sense of Domain Driven Design.
Maps Spring Data's CreatedDate annotation to DateCreated.
Type converters for supporting classes and interfaces in the org.springframework.data.domain package.
Spring JDBC Hibernate Session operations.
Spring integration implementation of HibernateCurrentSessionContextClassProvider.
Adds Spring Transaction management capability to Micronaut Data.
Maps Spring Data's Id to Id.
Spring JDBC connection operations.
Default implementation of TransactionOperations that uses Spring managed transactions.
Maps Spring's LastModifiedDate to DateUpdated.
Spring version of pageable binder.
Maps Spring Data's PersistenceConstructor to Creator.
Maps Spring Data's Persisted to MappedEntity.
Maps Spring's repository annotation to Micronaut's.
Maps Spring's TransactionalEventListener to Micronaut's.
Maps Spring's transaction annotation.
Maps Spring Data's Transient to Transient.
Maps Spring's Version to Version.
Subclass of DTOMapper specifically for SQL.
The provider for SqlJsonValueMapper when JSON columns are being written using SqlStoredQuery and for SqlJsonColumnReader when JSON columns are being read from SqlPreparedQuery results.
The SQL json column reader.
The SQL JSON parameter value mapper.
Interface for meta annotation members specific to SQL.
SQL version of SqlStoredQuery.
Implementation of QueryBuilder that builds SQL queries.
Allows configuration of how SQL queries are generated.
Configuration specific to a dialect.
A mapping function specific to SQL.
A TypeMapper that can take a RuntimePersistentEntity and a ResultReader and materialize an instance using using column naming conventions mapped by the entity.
The pushing mapper helper interface.
SQL version of BindableParametersStoredQuery carrying extra SQL related data.
A TypeMapper that specific to SQL.
Mapping StaticMetamodel to have reflective access.
Static metadata properties initializer.
This enum is used to tell how we should handle database and containers during startup.
Common super interface for all stored operations.
A stored computed query.
Stored query decorator.
The stored query parameter.
Stored query resolver.
Synchronous cascade operations.
The cascade operations helper.
The entities operations container.
The entity operations container.
The synchronous connection manager.
Implementation of the synchronous connection operations using a reactive connection operations.
NOTICE: This is a fork of Spring's PlatformTransactionManager modernizing it to use enums, Slf4j and decoupling from Spring.
Implementation of the synchronous transaction operations using a reactive transaction operations.
Maps JPA's Table annotation to MappedEntity.
Maps JPA's Table annotation to MappedEntity.
The tenant resolver for multi-tenancy.
Throughput settings for database and container.
Micronaut alternative jakarta.transaction.Transactional annotation.
Internal annotation applied to TransactionalEventListener that allows the interception of methods and binding the event consumer to the running transaction.
Interceptor implementation for TransactionalEventListener.
Largely based on the similar annotation in Spring.
The phase at which a transactional event listener applies.
Default implementation of Transactional.
A functional interface for running code that runs within the context of a transaction.
Resolves the tenant data source name for the transactional manager.
NOTICE: This is a fork of Spring's PlatformTransactionManager modernizing it to use enums, Slf4j and decoupling from Spring.
Isolation levels.
Possible propagation values.
Generic transaction exception super class.
Common representation of the current state of a transaction.
NOTICE: This is a fork of Spring's TransactionManager modernizing it to use enums, Slf4j and decoupling from Spring.
The transaction manager configuration.
Generic transaction operations interface.
The registry of various transactional operations managers.
The transaction state.
The transaction status.
Exception thrown when attempting to suspend an existing transaction but transaction suspension is not supported by the underlying backend.
Interface for transaction synchronization callbacks.
Transaction synchronization status.
Exception thrown when a general transaction system error is encountered, like on commit or rollback.
Exception to be thrown when a transaction has timed out.
Superclass for exceptions caused by inappropriate usage of a Micronaut transaction API.
Transaction utils.
Annotation used to indicate a field or method is transient and not persisted.
Maps JPA's Transient annotation to Transient.
Maps JPA's Transient annotation to Transient.
Serdeable mapper of Transient which marks fields annotated with Transient as serde ignored.
Type definitions allow associating existing types with a specific DataType.
Repeatable wrapper for TypeDef.
A context object to facilitate and ease mapping objects programmatically.
A type role indicates a method element in a repository that plays a role in query execution and should not be factored into query calculation but instead made available at runtime using the specified role name.
Internal utility methods.
Thrown when an attempt to commit a transaction resulted in an unexpected rollback.
Implementation of async updateAll(Specification).
Interface for the interceptor that handles updating a list or iterable of objects.
Interface for the interceptor that handles updating a list or iterable of objects.
Interface for the interceptor that handles updating a list or iterable of objects.
Implementation of async updateAll(Specification).
Implementation of updateAll(Specification).
Delete all specification method.
An interceptor that executes a batch update asynchronously.
A update batch operation is an operation performed on one or more entities of the same type.
Update criteria method match.
An interceptor that updates a single entity asynchronously.
Interceptor that handles update methods that take a single argument that is the entity.
An interceptor that updates a single entity reactively.
Implements update with lookup by id.
Update method matcher.
An update operation that updates the given entity.
An interceptor that saves a updates entity reactively.
Criteria update specification.
The mapping util class.
Supports generating UUIDs.
Designates a field or method that is used to version an entity.
Maps JPA's Version annotation to Micronaut's.
Maps JPA's Version annotation to Micronaut's.
Supports optimistic locking by using a version.
There Where annotation allows augmenting the WHERE statement of generated queries with additional criterion.
Repeatable annotation container for Where.