Jak wykonać zapytanie o limit w JPQL lub HQL?

Czy w Hibernacji 3 można zrobić równowartość następującego limitu MySQL w HQL?

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

Nie chcę używać setMaxResults, jeśli to możliwe. Było to zdecydowanie możliwe w starszej wersji Hibernacji / HQL, ale wydaje się, że zniknęło.

Zostało to opublikowane na forum Hibernate kilka lat temu, gdy zapytano go, dlaczego to działa w Hibernacji 2, ale nie w Hibernacji 3:

Limit nigdy nie był obsługiwaną klauzulą ​​w HQL. Masz zamiar użyć setMaxResults ().

Więc jeśli zadziałało w Hibernacji 2, wygląda na to, że był to przypadek, a nie projekt. Myślę, że było tak, ponieważ parser Hibernacji 2 HQL zastąpiłby bity zapytania, które rozpoznał jako HQL, i zostawił resztę bez zmian, abyś mógł się zakraść w natywnym SQL. Hibernacja 3 ma jednak odpowiedni parser AST HQL i jest o wiele mniej wybaczający.

Myślę, Query.setMaxResults()że to naprawdę twoja jedyna opcja.

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

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

Jeśli nie chcesz używać setMaxResults()tego Queryobiektu, zawsze możesz wrócić do używania normalnego SQL.

Jeśli nie chcesz używać setMaxResults, możesz także użyć Query.scroll zamiast listy i pobrać żądane wiersze. Przydatne na przykład dla stronicowania.

Możesz w tym celu łatwo zastosować podział na strony.

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

musisz przejść, new PageRequest(0, 1)aby pobrać rekordy, a z listy pobierz pierwszy rekord.

Ponieważ jest to bardzo częste pytanie, napisałem ten artykuł , na którym opiera się ta odpowiedź.

setFirstResultI setMaxResults Querymetody

Dla JPA i hibernacji QueryThe setFirstResultmetoda jest równoważne OFFSET, a setMaxResultssposób jest odpowiednikiem dopuszczalnych:

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

LimitHandlerabstrakcja

Hibernacja LimitHandlerdefiniuje logikę stronicowania specyficzną dla bazy danych i jak pokazano na poniższym diagramie, Hibernacja obsługuje wiele opcji stronicowania specyficznych dla bazy danych:

Teraz, w zależności od bazowego systemu relacyjnej bazy danych, którego używasz, powyższe zapytanie JPQL będzie używać właściwej składni stronicowania.

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 ?

SQL Server

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

Wyrocznia

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

Zaletą używania setFirstResulti setMaxResultsjest to, że Hibernacja może generować specyficzną dla bazy danych składnię stronicowania dla dowolnych obsługiwanych relacyjnych baz danych.

I nie jesteś ograniczony tylko do zapytań JPQL. Możesz użyć metody setFirstResulti setMaxResultssiódmej do natywnych zapytań SQL.

Natywne zapytania SQL

Podczas korzystania z rodzimych zapytań SQL nie trzeba kodować stronicowania specyficznego dla bazy danych. Hibernacja może dodać to do twoich zapytań.

Jeśli więc wykonujesz to zapytanie SQL na 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();

Hibernacja przekształci go w następujący sposób:

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

Fajnie, prawda?

Podział na strony poza SQL

Podział na strony jest dobry, gdy można indeksować kryteria filtrowania i sortowania. Jeśli twoje wymagania stronicowania wymagają dynamicznego filtrowania, o wiele lepiej jest zastosować rozwiązanie z indeksem odwróconym, takie jak ElasticSearch.

Sprawdź ten artykuł, aby uzyskać więcej informacji.

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

To działało dla mnie bez użycia setmaxResults();

Wystarczy podać maksymalną wartość w ostatnim (w tym przypadku 5) bez użycia słowa kluczowego limit. : P

Moje spostrzeżenie jest takie, że nawet ty masz limit w HQL (hibernacja 3.x), będzie to albo powodować błąd parsowania, albo po prostu zostanie zignorowany. (jeśli masz zamówienie przez + desc / asc przed limitem, zostanie zignorowane, jeśli nie masz desc / asc przed limitem, spowoduje błąd parsowania)

Jeśli można zarządzać limitem w tym trybie

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

To jest naprawdę prosty kod do obsługi limitu lub listy.

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

Musisz napisać natywne zapytanie, zapoznaj się z tym .

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

Możesz użyć poniższego zapytania

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

Poniższy fragment służy do wykonywania zapytań o limit przy użyciu HQL.

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

Możesz pobrać aplikację demonstracyjną pod tym linkiem .

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