Comment faire une requête limite en JPQL ou HQL?

Dans Hibernate 3, existe-t-il un moyen de faire l'équivalent de la limite MySQL suivante dans HQL?

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

Je ne veux pas utiliser setMaxResults si possible. Cela était certainement possible dans l'ancienne version de Hibernate / HQL, mais il semble avoir disparu.

Cela a été publié sur le forum Hibernate il y a quelques années lorsqu'on lui a demandé pourquoi cela fonctionnait dans Hibernate 2 mais pas dans Hibernate 3:

Limit n'a jamais été une clause prise en charge dans HQL. Vous êtes censé utiliser setMaxResults ().

Donc, si cela a fonctionné dans Hibernate 2, il semble que ce soit par hasard, plutôt que par conception. Je pense c'était parce que l'analyseur Hibernate 2 HQL remplacerait les bits de la requête qu'il reconnaissait comme HQL, et laisserait le reste tel qu'il était, afin que vous puissiez vous faufiler dans du SQL natif. Hibernate 3, cependant, a un analyseur AST HQL approprié, et c'est beaucoup moins indulgent.

Je pense que c'est Query.setMaxResults()vraiment votre seule option.

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

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

Si vous ne souhaitez pas l'utiliser setMaxResults()sur l' Queryobjet, vous pouvez toujours revenir à l'utilisation de SQL normal.

Si vous ne souhaitez pas utiliser setMaxResults, vous pouvez également utiliser Query.scroll au lieu de list et récupérer les lignes de votre choix. Utile pour la pagination par exemple.

Vous pouvez facilement utiliser la pagination pour cela.

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

vous devez passer new PageRequest(0, 1)pour récupérer les enregistrements et dans la liste récupérer le premier enregistrement.

Puisque c'est une question très courante, j'ai écrit cet article , sur lequel cette réponse est basée.

Les setFirstResultet setMaxResults Queryméthodes

Pour un JPA et Hibernate Query, la setFirstResultméthode est l'équivalent de OFFSET, et la setMaxResultsméthode est l'équivalent de LIMIT:

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

L' LimitHandlerabstraction

Hibernate LimitHandlerdéfinit la logique de pagination spécifique à la base de données et, comme illustré par le diagramme suivant, Hibernate prend en charge de nombreuses options de pagination spécifiques à la base de données:

Maintenant, selon le système de base de données relationnelle sous-jacent que vous utilisez, la requête JPQL ci-dessus utilisera la syntaxe de pagination appropriée.

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 ?

serveur 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

Oracle

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

L'avantage d'utiliser setFirstResultetsetMaxResults est qu'Hibernate peut générer la syntaxe de pagination spécifique à la base de données pour toutes les bases de données relationnelles prises en charge.

Et, vous n'êtes pas limité aux requêtes JPQL uniquement. Vous pouvez utiliser la méthode setFirstResultet setMaxResultssept pour les requêtes SQL natives.

Requêtes SQL natives

Vous n'avez pas à coder en dur la pagination spécifique à la base de données lorsque vous utilisez des requêtes SQL natives. Hibernate peut ajouter cela à vos requêtes.

Donc, si vous exécutez cette requête SQL sur 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 le transformera comme suit:

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

Cool, non?

Au-delà de la pagination basée sur SQL

La pagination est bonne lorsque vous pouvez indexer les critères de filtrage et de tri. Si vos exigences de pagination impliquent un filtrage dynamique, c'est une bien meilleure approche que d'utiliser une solution à index inversé, comme ElasticSearch.

Consultez cet article pour plus de détails.

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

Cela a fonctionné pour moi sans utiliser setmaxResults();

Fournissez simplement la valeur maximale dans le dernier (dans ce cas 5) sans utiliser le mot clé limit. : P

Mon observation est que même si vous avez une limite dans le HQL (hibernate 3.x), cela provoquera une erreur d'analyse ou sera simplement ignoré. (si vous avez commandé par + desc / asc avant la limite, il sera ignoré, si vous n'avez pas desc / asc avant la limite, cela provoquera une erreur d'analyse)

Si peut gérer une limite dans ce mode

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

Il s'agit d'un code très simple pour gérer une limite ou une liste.

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

Vous devez écrire une requête native, référez - vous à ceci .

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

Vous pouvez utiliser la requête ci-dessous

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

L'extrait ci-dessous est utilisé pour effectuer une requête de limite à l'aide de HQL.

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

Vous pouvez obtenir une application de démonstration sur ce lien .

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