Dati primari - Perché non è possibile avere il cercapersone con query nativa

Question

Diciamo che abbiamo un'entità chiamata MyEntity. È possibile interrogare i risultati pagabili usando @Query e con le query denominate, ad es.

@Query(value = "select e from MyEntity e where e.enabled = true") 
Page<MyEntity> findAllEnabled(Pageable pageable); 

Tuttavia, non è possibile ottenere lo stesso con interrogazione nativo, quindi questo

@Query(value = "select * from my_entity where enabled = true", nativeQuery = true) 
Page<MyEntity> findAllEnabled(Pageable pageable); 

non funzionerà.

Quali sono le ragioni di questo? È possibile rendere Pageable funzionante con query native?

Answer 1

Questa è la descrizione, data in primavera documentazione dei dati JPA (http://docs.spring.io/spring-data/jpa/docs/1.8.0.M1/reference/html/)

Native queriesThe @query annotazione consente di eseguire le query native impostando il flag nativeQuery su true. Nota che attualmente non supportiamo l'esecuzione di paginazione o l'ordinamento dinamico per le query native come dovremmo gestire la query effettiva dichiarata e non possiamo fare questo affidabile per SQL nativo.

JPQL riassume l'implementazione SQL e le specifiche dei provider e rende la responsabilità del framework ORM per generare SQL corretto.

1. Quindi, utilizzando paginazione in forma JPQL, Primavera ha solo bisogno di generare corretta JPQL, e sarà interpretata a livello ORM per correggere SQL.

2. Mentre si fa così con SQL, implicherebbe che Spring sappia come generare SQL corretto per le grandi maggioranze di RDBMS, duplicando la funzionalità ORM, che è troppo sovraccarico.

Answer 2

Non so se questo è ancora relativo al sistema: Almeno in primavera dati JPA 1.9.4 è possibile specificare due query.

dato un repository:

interface FoobarEntityRepository extends JpaRepository<FoobarEntity, Integer> { 
    Page findFoobarsSpecialQuery(String someParameter, final Pageable pageable); 
} 

È possibile aggiungere 2 query nativi vostra entità, una per la query stessa e uno per la dichiarazione conteggio:

@Entity 
@SqlResultSetMappings({ 
    @SqlResultSetMapping(name = "SqlResultSetMapping.count", columns = @ColumnResult(name = "cnt")) 
}) 
@NamedNativeQueries({ 
    @NamedNativeQuery(
      name = "FoobarEntity.findFoobarsSpecialQuery", 
      resultClass = DailyPictureEntity.class, 
      query = "Select * from foobars f where someValue = :someParameter " 
    ), 
    @NamedNativeQuery(
      name = "FoobarEntity.findFoobarsSpecialQuery.count", 
      resultSetMapping = "SqlResultSetMapping.count", 
      query = "Select count(*) as cnt from foobars f where someValue = :someParameter " 
    ) 
}) 
FoobarEntity { 
} 

Il trucco è quello di specificare la conta la query con il suffisso .count. Funziona anche con l'annotazione Spring Data @Query.

Si noti che è necessario un mapping del set di risultati SQL per la query di conteggio, tuttavia.

Questo funziona davvero molto bene.

Answer 3

Esiste un modo per utilizzare Pageable con query native con la capacità SpEL dei dati Spring, è lo here.

È possibile trovare un esempio in this repository.

/** 
    * @see DATAJPA-564 
    */ 
    @Query(
      value = "select * from (select rownum() as RN, u.* from SD_User u) where RN between ?#{ #pageable.offset -1} and ?#{#pageable.offset + #pageable.pageSize}", 
      countQuery = "select count(u.id) from SD_User u", nativeQuery = true) 
    Page<User> findUsersInNativeQueryWithPagination(Pageable pageable); 

Il functionnality sorta non funziona correttamente se c'è una sottoquery nella clausola from o la query nativa e si desidera applicare una sorta dinamica su di esso. Il modo in cui può essere fatto è spostare la sottoquery nella clausola where.
I dati di primavera verranno aggiunti allo fine della richiesta " order by " se è presente un oggetto Sort nello Pageable. (con dati Spring 1.10.3)

Un modo migliore è convertire la query nativa in jpql se possibile.