Package in.co.akshitbansal.springwebquery.repository

Class WebQueryRepositoryImpl<T>

java.lang.Object
in.co.akshitbansal.springwebquery.repository.WebQueryRepositoryImpl<T>
Type Parameters:
T - entity type backing the repository
All Implemented Interfaces:
WebQueryRepository<T>, org.springframework.data.repository.core.support.RepositoryMetadataAccess
public class WebQueryRepositoryImpl<T> extends Object implements WebQueryRepository<T>, org.springframework.data.repository.core.support.RepositoryMetadataAccess
Spring Data fragment implementation for WebQueryRepository.

This implementation resolves the current repository domain type through RepositoryMethodContext and uses the JPA Criteria API to execute tuple and count queries. Paged execution derives totals from a separate count query built from the Specification, so row-cardinality changes applied through SelectionsProvider only affect the result query.

  • Constructor Summary

    Constructors
    Constructor
    Description
    WebQueryRepositoryImpl()
     

  • Method Summary

    Modifier and Type
    Method
    Description
    List<jakarta.persistence.Tuple>
    findAll(@NonNull org.springframework.data.jpa.domain.Specification<T> specification, @NonNull org.springframework.data.domain.Pageable pageable, @NonNull SelectionsProvider<T> selectionsProvider)
    Executes a tuple query for the given specification, sort/page request, and selection definition.
    <U> List<U>
    findAll(@NonNull org.springframework.data.jpa.domain.Specification<T> specification, @NonNull org.springframework.data.domain.Pageable pageable, @NonNull SelectionsProvider<T> selectionsProvider, @NonNull Class<U> dtoClass)
    Executes a tuple query and converts each result row into an instance of the requested DTO type.
    org.springframework.data.domain.Page<jakarta.persistence.Tuple>
    findAllPaged(@NonNull org.springframework.data.jpa.domain.Specification<T> specification, @NonNull org.springframework.data.domain.Pageable pageable, @NonNull SelectionsProvider<T> selectionsProvider)
    Executes a tuple query and wraps the results in a page.
    <U> org.springframework.data.domain.Page<U>
    findAllPaged(org.springframework.data.jpa.domain.Specification<T> specification, org.springframework.data.domain.Pageable pageable, SelectionsProvider<T> selectionsProvider, Class<U> dtoClass)
    Executes a tuple query, converts each result row into an instance of the requested DTO type, and wraps the converted results in a page.

    Methods inherited from class java.lang.Object

    clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

  • Constructor Details

    • WebQueryRepositoryImpl

      public WebQueryRepositoryImpl()

  • Method Details

    • findAll

      public List<jakarta.persistence.Tuple> findAll(@NonNull @NonNull org.springframework.data.jpa.domain.Specification<T> specification, @NonNull @NonNull org.springframework.data.domain.Pageable pageable, @NonNull @NonNull SelectionsProvider<T> selectionsProvider)
      Description copied from interface: WebQueryRepository
      Executes a tuple query for the given specification, sort/page request, and selection definition.

      The selection callback receives the live result CriteriaQuery so it can build correlated subqueries or inspect query state while defining projected columns.

      Specified by:
      findAll in interface WebQueryRepository<T>
      Parameters:
      specification - filtering criteria to apply
      pageable - paging and sorting information; sorting is always applied and limits are applied when paged
      selectionsProvider - callback that defines the tuple selections for the query
      Returns:
      tuples matching the requested filter, sort, and selection set

    • findAllPaged

      public org.springframework.data.domain.Page<jakarta.persistence.Tuple> findAllPaged(@NonNull @NonNull org.springframework.data.jpa.domain.Specification<T> specification, @NonNull @NonNull org.springframework.data.domain.Pageable pageable, @NonNull @NonNull SelectionsProvider<T> selectionsProvider)
      Description copied from interface: WebQueryRepository
      Executes a tuple query and wraps the results in a page.

      When pageable is unpaged, the returned page contains all matching tuples without issuing a separate count query.

      The selection callback receives the live result CriteriaQuery. For paged execution, avoid mutating the outer query in ways that change row cardinality, such as enabling distinct results or adding grouping, because the total count is derived from a separate count query built from the Specification.

      Specified by:
      findAllPaged in interface WebQueryRepository<T>
      Parameters:
      specification - filtering criteria to apply
      pageable - paging and sorting information; sorting is always applied and limits are applied when paged
      selectionsProvider - callback that defines the tuple selections for the query
      Returns:
      a page of tuples matching the requested filter, sort, and selection set

    • findAll

      public <U> List<U> findAll(@NonNull @NonNull org.springframework.data.jpa.domain.Specification<T> specification, @NonNull @NonNull org.springframework.data.domain.Pageable pageable, @NonNull @NonNull SelectionsProvider<T> selectionsProvider, @NonNull @NonNull Class<U> dtoClass)
      Description copied from interface: WebQueryRepository
      Executes a tuple query and converts each result row into an instance of the requested DTO type.

      Use this overload when the caller wants constructor-backed DTO projection instead of working with raw Tuple instances. The provided SelectionsProvider still defines the tuple projection, but each resulting row is converted into dtoClass immediately before being returned to the caller.

      Conversion is positional. The selected tuple elements are passed to the DTO constructor in the same order as they are returned by SelectionsProvider.getSelections(jakarta.persistence.criteria.Root<T>, jakarta.persistence.criteria.CriteriaQuery<?>, jakarta.persistence.criteria.CriteriaBuilder). Tuple aliases or selection names are ignored.

      A constructor is considered compatible when it has the same number of parameters as projected tuple elements and each parameter type is assignable from the corresponding tuple element runtime Java type after primitive types are normalized to their wrapper equivalents. When multiple constructors are compatible, a constructor annotated with PersistenceCreator is preferred. Callers should define at most one such annotated constructor; if more than one constructor is annotated, or if multiple compatible constructors exist and selection is not uniquely determined, behavior is unpredictable.

      If no compatible constructor can be found, or if reflective instantiation fails for any row, the conversion fails at runtime.

      Specified by:
      findAll in interface WebQueryRepository<T>
      Type Parameters:
      U - DTO projection type
      Parameters:
      specification - filtering criteria to apply
      pageable - paging and sorting information; sorting is always applied and limits are applied when paged
      selectionsProvider - callback that defines the tuple selections for the query
      dtoClass - target DTO type to instantiate for each tuple row
      Returns:
      DTO instances matching the requested filter, sort, selection set, and constructor mapping rules

    • findAllPaged

      public <U> org.springframework.data.domain.Page<U> findAllPaged(org.springframework.data.jpa.domain.Specification<T> specification, org.springframework.data.domain.Pageable pageable, SelectionsProvider<T> selectionsProvider, Class<U> dtoClass)
      Description copied from interface: WebQueryRepository
      Executes a tuple query, converts each result row into an instance of the requested DTO type, and wraps the converted results in a page.

      Use this overload when the caller wants constructor-backed DTO projection together with Spring Data paging metadata. The provided SelectionsProvider still defines the tuple projection, and each tuple row is converted into dtoClass before being exposed in the returned page.

      Conversion is positional. The selected tuple elements are supplied to the DTO constructor in the same order as they are returned by SelectionsProvider.getSelections(jakarta.persistence.criteria.Root<T>, jakarta.persistence.criteria.CriteriaQuery<?>, jakarta.persistence.criteria.CriteriaBuilder). Tuple aliases or selection names do not participate in constructor binding.

      A constructor is considered compatible when it has the same number of parameters as projected tuple elements and each parameter type is assignable from the corresponding tuple element runtime Java type after primitive types are normalized to their wrapper equivalents. When multiple constructors are compatible, a constructor annotated with PersistenceCreator is preferred. Callers should define at most one such annotated constructor; if more than one constructor is annotated, or if multiple compatible constructors exist and selection is not uniquely determined, behavior is unpredictable.

      This method inherits the same count-query caveats as WebQueryRepository.findAllPaged(Specification, Pageable, SelectionsProvider). In particular, callers should avoid mutating the outer query in ways that change row cardinality, because the total count is derived from a separate count query built from the Specification.

      If no compatible constructor can be found, or if reflective instantiation fails for any row, the conversion fails at runtime.

      Specified by:
      findAllPaged in interface WebQueryRepository<T>
      Type Parameters:
      U - DTO projection type
      Parameters:
      specification - filtering criteria to apply
      pageable - paging and sorting information; sorting is always applied and limits are applied when paged
      selectionsProvider - callback that defines the tuple selections for the query
      dtoClass - target DTO type to instantiate for each tuple row
      Returns:
      a page of DTO instances matching the requested filter, sort, selection set, and constructor mapping rules