Module io.helidon.data

Package io.helidon.data

package io.helidon.data

Helidon Data Repository.

The Helidon Data Repository provides unified API to work with database queries. Data repository queries are an abstraction on top of Object–Relational Mapping (ORM). They allow compile time translation of interfaces with query definitions into implementing classes.

Data repository queries are methods of interfaces that extend Data.GenericRepository. Data repository queries can be implemented in three ways:

• using method annotated with Data.Query
• using method name as query definition
• extending existing Data.GenericRepository child interfaces with common sets of query methods:
  • Data.BasicRepository to implement basic set of entity operations
  • Data.CrudRepository to implement entity CRUD operations
  • Data.PageableRepository to implement pageable Data.BasicRepository.findAll() queries
  • Data.SessionRepository to get access to persistence provider's session, e.g. jakarta.persistence.EntityManager

This is a preview feature of Helidon - it is ready for production use, but we reserve the rights to change APIs without the usual deprecation process. This feature will be backward compatible within a major version of Helidon.

Related Packages

Module	Package	Description
io.helidon	io.helidon	Startup of Helidon applications.
io.helidon.data.codegen	io.helidon.data.codegen	Code processing and generation with Helidon Data API.

Class	Description
Data	Helidon Data Repository annotations and interfaces.
Data.BasicRepository<E,ID>	Data repository interface for basic entity operations.
Data.CrudRepository<E,ID>	Data repository interface for CRUD entity operations.
Data.GenericRepository<E,ID>	Data repository interface.
Data.PageableRepository<E,ID>	A Data.GenericRepository that supports pagination.
Data.PersistenceUnit	Repository persistence unit name.
Data.Provider	Provider used to implement the repository.
Data.ProviderType	Qualifier used in generated code to reference which provider type to use when creating instances of repositories, such as eclipselink, jakarta, sql.
Data.Query	User supplied query.
Data.Repository	Repository interface.
Data.SessionRepository<S>	Data repository interface with persistence provider session support.
DataException	A RuntimeException that indicates an operation on a data repository has failed.
EntityExistsException	Thrown when persistence entity being inserted already exists.
EntityNotFoundException	Thrown when requested persistence entity cannot be found.
NonUniqueResultException	Thrown when a query was expected to produce exactly one record but produced many instead.
NoResultException	Thrown when a query was expected to produce a result, but did not.
OptimisticLockException	Thrown when an optimistic locking conflict occurs.
Order	Single rule of the dynamic ordering of the query result.
Order.Builder	Fluent API builder for Order.
Order.BuilderBase<BUILDER extends Order.BuilderBase<BUILDER,PROTOTYPE>,PROTOTYPE extends Order>	Fluent API builder base for Order.
Order.BuilderBase.OrderImpl	Generated implementation of the prototype, can be extended by descendant prototype implementations.
OrderDirection	Direction of the query result ordering.
Page<T>	Pageable query result as pages with total size of the result.
PageRequest	Request pageable query result as page with page number and size.
PageRequest.Builder	Fluent API builder for PageRequest.
PageRequest.BuilderBase<BUILDER extends PageRequest.BuilderBase<BUILDER,PROTOTYPE>,PROTOTYPE extends PageRequest>	Fluent API builder base for PageRequest.
PageRequest.BuilderBase.PageRequestImpl	Generated implementation of the prototype, can be extended by descendant prototype implementations.
Slice<T>	Pageable query result as pages without total size of the result.
Sort	Dynamic ordering of the query result.
Sort.Builder	Fluent API builder for Sort.
Sort.BuilderBase<BUILDER extends Sort.BuilderBase<BUILDER,PROTOTYPE>,PROTOTYPE extends Sort>	Fluent API builder base for Sort.
Sort.BuilderBase.SortImpl	Generated implementation of the prototype, can be extended by descendant prototype implementations.