Como você faz uma consulta de limite no JPQL ou HQL?

No Hibernate 3, existe uma maneira de fazer o equivalente ao seguinte limite do MySQL no HQL?

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

Não quero usar setMaxResults, se possível. Definitivamente, isso foi possível na versão mais antiga do Hibernate / HQL, mas parece ter desaparecido.

Isso foi postado no fórum do Hibernate alguns anos atrás, quando perguntado sobre por que isso funcionou no Hibernate 2, mas não no Hibernate 3:

Limite nunca foi uma cláusula suportada no HQL. Você deve usar setMaxResults ().

Portanto, se funcionou no Hibernate 2, parece que foi por coincidência, e não por design. Eu acho que isso ocorreu porque o analisador Hibernate 2 HQL substituiria os bits da consulta que reconhecia como HQL e deixaria o restante como estava, para que você pudesse esgueirar-se em algum SQL nativo. O Hibernate 3, no entanto, possui um Analisador AST HQL adequado, e é muito menos tolerante.

Eu acho que Query.setMaxResults()realmente é sua única opção.

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

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

Se você não quiser usar setMaxResults()o Queryobjeto, poderá sempre voltar a usar o SQL normal.

Se você não quiser usar o setMaxResults, também poderá usar o Query.scroll em vez da lista e buscar as linhas que desejar. Útil para paginação, por exemplo.

Você pode facilmente usar a paginação para isso.

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

você precisa passar new PageRequest(0, 1)para buscar registros e da lista buscar o primeiro registro.

Como essa é uma pergunta muito comum, escrevi este artigo , no qual essa resposta se baseia.

Os métodos setFirstResultesetMaxResults Query

Para uma JPA e Hibernate Query, o setFirstResultmétodo é equivalente ae OFFSETo setMaxResultsmétodo é equivalente a LIMIT:

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

A LimitHandlerabstração

O Hibernate LimitHandlerdefine a lógica de paginação específica do banco de dados e, conforme ilustrado no diagrama a seguir, o Hibernate suporta muitas opções de paginação específicas do banco de dados:

Agora, dependendo do sistema de banco de dados relacional subjacente que você estiver usando, a consulta JPQL acima usará a sintaxe de paginação apropriada.

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 ?

servidor 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

Oráculo

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_ > ?

A vantagem de usar setFirstResulte setMaxResultsé que o Hibernate pode gerar a sintaxe de paginação específica do banco de dados para qualquer banco de dados relacional suportado.

E você não está limitado apenas às consultas JPQL. Você pode usar o método setFirstResulte setMaxResultssete para consultas SQL nativas.

Consultas SQL nativas

Você não precisa codificar a paginação específica do banco de dados ao usar consultas SQL nativas. O Hibernate pode adicionar isso às suas consultas.

Portanto, se você estiver executando esta consulta SQL no 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();

O Hibernate irá transformá-lo da seguinte maneira:

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

Legal certo?

Além da paginação baseada em SQL

A paginação é boa quando você pode indexar os critérios de filtragem e classificação. Se seus requisitos de paginação implicam filtragem dinâmica, é uma abordagem muito melhor usar uma solução de índice invertido, como o ElasticSearch.

Confira este artigo para mais detalhes.

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

Isso funcionou para mim sem usar setmaxResults();

Basta fornecer o valor máximo no último (neste caso, 5) sem usar a palavra-chave limit. : P

Minha observação é que, mesmo que você tenha limite no HQL (hibernate 3.x), ele estará causando um erro de análise ou apenas será ignorado. (se você pedir por + desc / asc antes do limite, ele será ignorado; se você não tiver desc / asc antes do limite, isso causará erro de análise)

Se pode gerenciar um limite neste modo

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();
}

Este é um código realmente simples para lidar com um limite ou uma lista.

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());
            }

Você precisa escrever uma consulta nativa, consulte isso .

@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);

Você pode usar a consulta abaixo

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

O trecho abaixo é usado para executar a consulta de limite usando o HQL.

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

Você pode obter o aplicativo de demonstração neste 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);