Come si fa una query limite in JPQL o HQL?

In Hibernate 3, c'è un modo per fare l'equivalente del seguente limite MySQL in HQL?

select * from a_table order by a_table_column desc limit 0, 20;

Non voglio usare setMaxResults se possibile. Ciò è stato sicuramente possibile nella versione precedente di Hibernate / HQL, ma sembra essere scomparso.

Questo è stato pubblicato sul forum di Hibernate alcuni anni fa quando gli è stato chiesto perché funzionasse in Hibernate 2 ma non in Hibernate 3:

Il limite non è mai stato una clausola supportata in HQL. Si intende utilizzare setMaxResults ().

Quindi, se ha funzionato in Hibernate 2, sembra che sia stato un caso, piuttosto che un design. Io penso ciò sia dovuto al fatto che il parser Hibernate 2 HQL avrebbe sostituito i bit della query che riconosceva come HQL e avrebbe lasciato il resto com'era, in modo da poter intrufolarsi in alcuni SQL nativi. Hibernate 3, tuttavia, ha un vero parser HQL AST ed è molto meno tollerante.

Penso che sia Query.setMaxResults()davvero la tua unica opzione.

 // SQL: SELECT * FROM table LIMIT start, maxRows;

Query q = session.createQuery("FROM table");
q.setFirstResult(start);
q.setMaxResults(maxRows);

Se non si desidera utilizzare setMaxResults()l' Queryoggetto, è possibile tornare sempre all'utilizzo di SQL normale.

Se non vuoi usare setMaxResults, puoi anche usare Query.scroll invece dell'elenco e recuperare le righe che desideri. Utile ad esempio per il paging.

Puoi facilmente usare l'impaginazione per questo.

    @QueryHints({ @QueryHint(name = "org.hibernate.cacheable", value = "true") })
    @Query("select * from a_table order by a_table_column desc")
    List<String> getStringValue(Pageable pageable);

devi passare new PageRequest(0, 1)per recuperare i record e dall'elenco recuperare il primo record.

Poiché questa è una domanda molto comune, ho scritto questo articolo , su cui si basa questa risposta.

I metodi setFirstResultesetMaxResults Query

Per un JPA e Hibernate Query, il setFirstResultmetodo è l'equivalente di OFFSETe il setMaxResultsmetodo è l'equivalente di LIMIT:

List<Post> posts = entityManager
.createQuery(
    "select p " +
    "from Post p " +
    "order by p.createdOn ")
.setFirstResult(10)
.setMaxResults(10)
.getResultList();

L' LimitHandlerastrazione

Hibernate LimitHandlerdefinisce la logica di impaginazione specifica del database e, come illustrato dal diagramma seguente, Hibernate supporta molte opzioni di impaginazione specifiche del database:

Ora, a seconda del sistema di database relazionale sottostante che si sta utilizzando, la query JPQL precedente utilizzerà la sintassi di impaginazione corretta.

MySQL

SELECT p.id AS id1_0_,
       p.created_on AS created_2_0_,
       p.title AS title3_0_
FROM post p
ORDER BY p.created_on
LIMIT ?, ?

PostgreSQL

SELECT p.id AS id1_0_,
       p.created_on AS created_2_0_,
       p.title AS title3_0_
FROM post p
ORDER BY p.created_on
LIMIT ?
OFFSET ?

server SQL

SELECT p.id AS id1_0_,
       p.created_on AS created_on2_0_,
       p.title AS title3_0_
FROM post p
ORDER BY p.created_on
OFFSET ? ROWS 
FETCH NEXT ? ROWS ONLY

Oracolo

SELECT *
FROM (
    SELECT 
        row_.*, rownum rownum_
    FROM (
        SELECT 
            p.id AS id1_0_,
            p.created_on AS created_on2_0_,
            p.title AS title3_0_
        FROM post p
        ORDER BY p.created_on
    ) row_
    WHERE rownum <= ?
)
WHERE rownum_ > ?

Il vantaggio di usare setFirstResultesetMaxResults è che Hibernate può generare la sintassi di impaginazione specifica del database per qualsiasi database relazionale supportato.

E non sei limitato solo alle query JPQL. È possibile utilizzare il metodo setFirstResulte setMaxResultssette per le query SQL native.

Query SQL native

Non è necessario codificare in modo rigido l'impaginazione specifica del database quando si utilizzano query SQL native. Hibernate può aggiungerlo alle tue domande.

Quindi, se stai eseguendo questa query SQL su PostgreSQL:

List<Tuple> posts = entityManager
.createNativeQuery(
    "SELECT " +
    "   p.id AS id, " +
    "   p.title AS title " +
    "from post p " +
    "ORDER BY p.created_on", Tuple.class)
.setFirstResult(10)
.setMaxResults(10)
.getResultList();

Hibernate lo trasformerà come segue:

SELECT p.id AS id,
       p.title AS title
FROM post p
ORDER BY p.created_on
LIMIT ?
OFFSET ?

Bene, vero?

Oltre l'impaginazione basata su SQL

L'impaginazione è buona quando è possibile indicizzare i criteri di filtro e ordinamento. Se i requisiti di impaginazione implicano un filtro dinamico, è un approccio molto migliore l'utilizzo di una soluzione con indice invertito, come ElasticSearch.

Dai un'occhiata a questo articolo per maggiori dettagli.

String hql = "select userName from AccountInfo order by points desc 5";

Questo ha funzionato per me senza usare setmaxResults();

Fornisci il valore massimo nell'ultimo (in questo caso 5) senza usare la parola chiave limit. : P

La mia osservazione è che anche se hai un limite in HQL (ibernazione 3.x), causerà un errore di analisi o semplicemente verrà ignorato. (se hai un ordine di + desc / asc prima del limite, verrà ignorato, se non hai desc / asc prima del limite, causerà un errore di analisi)

Se riesco a gestire un limite in questa modalità

public List<ExampleModel> listExampleModel() {
    return listExampleModel(null, null);
}

public List<ExampleModel> listExampleModel(Integer first, Integer count) {
    Query tmp = getSession().createQuery("from ExampleModel");

    if (first != null)
        tmp.setFirstResult(first);
    if (count != null)
        tmp.setMaxResults(count);

    return (List<ExampleModel>)tmp.list();
}

Questo è un codice davvero semplice per gestire un limite o un elenco.

Criteria criteria=curdSession.createCriteria(DTOCLASS.class).addOrder(Order.desc("feild_name"));
                criteria.setMaxResults(3);
                List<DTOCLASS> users = (List<DTOCLASS>) criteria.list();
for (DTOCLASS user : users) {
                System.out.println(user.getStart());
            }

È necessario scrivere una query nativa, fare riferimento a questo .

@Query(value =
    "SELECT * FROM user_metric UM WHERE UM.user_id = :userId AND UM.metric_id = :metricId LIMIT :limit", nativeQuery = true)
List<UserMetricValue> findTopNByUserIdAndMetricId(
    @Param("userId") String userId, @Param("metricId") Long metricId,
    @Param("limit") int limit);

È possibile utilizzare la query seguente

NativeQuery<Object[]> query = session.createNativeQuery(select * from employee limit ?)
query.setparameter(1,1);

Lo snippet di seguito viene utilizzato per eseguire query con limite utilizzando HQL.

Query query = session.createQuery("....");
query.setFirstResult(startPosition);
query.setMaxResults(maxRows);

È possibile ottenere l'applicazione demo a questo link .

@Query(nativeQuery = true,
       value = "select from otp u where u.email =:email order by u.dateTime desc limit 1")
public List<otp> findOtp(@Param("email") String email);