¿Cómo se hace una consulta de límite en JPQL o HQL?

En Hibernate 3, ¿hay alguna manera de hacer el equivalente del siguiente límite de MySQL en HQL?

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

No quiero usar setMaxResults si es posible. Esto definitivamente fue posible en la versión anterior de Hibernate / HQL, pero parece haber desaparecido.

Esto fue publicado en el foro de Hibernate hace unos años cuando se le preguntó por qué esto funcionó en Hibernate 2 pero no en Hibernate 3:

El límite nunca fue una cláusula admitida en HQL. Debes usar setMaxResults ().

Entonces, si funcionó en Hibernate 2, parece que fue por coincidencia, en lugar de por diseño. Creo que esto se debió a que el analizador HQL de Hibernate 2 reemplazaría los bits de la consulta que reconoció como HQL, y dejaría el resto como estaba, para que pueda colarse en un SQL nativo. Hibernate 3, sin embargo, tiene un analizador AST HQL adecuado, y es mucho menos indulgente.

Creo que Query.setMaxResults()realmente es tu única opción.

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

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

Si no desea usar setMaxResults()el Queryobjeto, siempre puede volver a usar SQL normal.

Si no desea usar setMaxResults, también puede usar Query.scroll en lugar de list y buscar las filas que desee. Útil para paginación por ejemplo.

Puede usar fácilmente la paginación para esto.

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

tienes que pasar new PageRequest(0, 1)para buscar registros y de la lista buscar el primer registro.

Como esta es una pregunta muy común, escribí este artículo , en el que se basa esta respuesta.

Los setFirstResulty setMaxResults Querymétodos

Para un JPA e Hibernate Query, el setFirstResultmétodo es el equivalente de OFFSET, y el setMaxResultsmétodo es el equivalente de LIMIT:

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

La LimitHandlerabstraccion

Hibernate LimitHandlerdefine la lógica de paginación específica de la base de datos y, como se ilustra en el siguiente diagrama, Hibernate admite muchas opciones de paginación específicas de la base de datos:

Ahora, dependiendo del sistema de base de datos relacional subyacente que esté utilizando, la consulta JPQL anterior utilizará la sintaxis de paginación adecuada.

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

La ventaja de usar setFirstResulty setMaxResultses que Hibernate puede generar la sintaxis de paginación específica de la base de datos para cualquier base de datos relacional compatible.

Y no está limitado únicamente a consultas JPQL. Puede usar el método setFirstResulty setMaxResultssiete para consultas SQL nativas.

Consultas SQL nativas

No tiene que codificar la paginación específica de la base de datos cuando utiliza consultas SQL nativas. Hibernate puede agregar eso a sus consultas.

Entonces, si está ejecutando esta consulta SQL en 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 transformará de la siguiente manera:

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

¿Guay, verdad?

Más allá de la paginación basada en SQL

La paginación es buena cuando puede indexar los criterios de filtrado y clasificación. Si sus requisitos de paginación implican un filtrado dinámico, es un enfoque mucho mejor utilizar una solución de índice invertido, como ElasticSearch.

Mira este artículo para más detalles.

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

Esto funcionó para mí sin usar setmaxResults();

Solo proporcione el valor máximo en el último (en este caso 5) sin usar la palabra clave limit. :PAGS

Mi observación es que incluso si tiene un límite en la HQL (hibernate 3.x), causará un error de análisis o simplemente se ignorará. (si tiene orden por + desc / asc antes del límite, se ignorará, si no tiene desc / asc antes del límite, causará un error de análisis)

Si puede administrar un límite en este 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 es un código realmente simple para manejar un límite o una 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());
            }

Necesita escribir una consulta nativa, consulte esto .

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

Puedes usar la consulta a continuación

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

El fragmento a continuación se utiliza para realizar consultas de límite utilizando HQL.

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

Puede obtener la aplicación de demostración en este enlace .

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