web-dev-qa-db-ja.com

選択クエリとカウントクエリを実行するよりもHibernateでページ分割を行うより効率的な方法はありますか？

通常、ページネーションクエリは次のようになります。ほぼ同じ2つのメソッドを作成する代わりに、「select * ...」と「count * ...」を実行するより良い方法はありますか？

public List<Cat> findCats(String name, int offset, int limit) {

    Query q = session.createQuery("from Cat where name=:name");

    q.setString("name", name);

    if (offset > 0) {
        q.setFirstResult(offset);
    }
    if (limit > 0) {
        q.setMaxResults(limit);
    }

    return q.list();

}

public Long countCats(String name) {
    Query q = session.createQuery("select count(*) from Cat where name=:name");
    q.setString("name", name);
    return (Long) q.uniqueResult();
}
javamysqlhibernatepaginationhql
38
serg

MySQLPerformanceBlog.comのバロンシュワルツは、これについて post を作成しました。この問題に魔法の弾丸があったらいいのにと思いますが、ありません。彼が提示したオプションの要約：

  1. 最初のクエリで、すべての結果をフェッチしてキャッシュします。
  2. すべての結果を表示しないでください。
  3. 総数や他のページへの中間リンクを表示しないでください。 「次の」リンクのみを表示します。
  4. 結果の数を推定します。
11
Eric R. Rath

私のソリューションは、Hibernate + Spring + MySQLの非常に一般的な使用例で機能します

上記の回答と同様に、私は Dr Richard Kennar's に基づいて私の解決策を導きました。ただし、HibernateはしばしばSpringで使用されるため、SpringとHibernateを使用するための標準的な方法で非常にうまく機能するソリューションを望みました。したがって、私のソリューションでは、スレッドローカルとシングルトンBeanの組み合わせを使用して結果を達成しています。技術的には、インターセプターはSessionFactoryの準備されたすべてのSQLステートメントで呼び出されますが、すべての行をカウントするように特別に設定されたクエリでない限り、すべてのロジックをスキップし、ThreadLocalを初期化しません。

以下のクラスを使用すると、Spring構成は次のようになります。

<bean id="foundRowCalculator" class="my.hibernate.classes.MySQLCalcFoundRowsInterceptor" />
    <!-- p:sessionFactoryBeanName="mySessionFactory"/ -->

<bean id="mySessionFactory"
    class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean"
    p:dataSource-ref="dataSource"
    p:packagesToScan="my.hibernate.classes"
    p:entityInterceptor-ref="foundRowCalculator"/>

基本的に、インターセプターBeanを宣言してから、SessionFactoryBeanの「entityInterceptor」プロパティーでそれを参照する必要があります。 Springコンテキストに複数のSessionFactoryがあり、参照するセッションファクトリが「sessionFactory」と呼ばれていない場合にのみ、「sessionFactoryBeanName」を設定する必要があります。参照を設定できないのは、これにより、解決できないBean間の相互依存が発生するためです。

結果にラッパーBeanを使用する：

package my.hibernate.classes;

public class PagedResponse<T> {
    public final List<T> items;
    public final int total;
    public PagedResponse(List<T> items, int total) {
        this.items = items;
        this.total = total;
    }
}

次に、抽象基本DAOクラスを使用して、クエリを実行する前に "setCalcFoundRows（true）"を呼び出し、[finallyブロック内で]呼び出した後に "reset（）"を呼び出す必要があります。

package my.hibernate.classes;

import org.hibernate.Criteria;
import org.hibernate.Query;
import org.springframework.beans.factory.annotation.Autowired;

public abstract class BaseDAO {

    @Autowired
    private MySQLCalcFoundRowsInterceptor rowCounter;

    public <T> PagedResponse<T> getPagedResponse(Criteria crit, int firstResult, int maxResults) {
        rowCounter.setCalcFoundRows(true);
        try {
            @SuppressWarnings("unchecked")
            return new PagedResponse<T>(
                crit.
                setFirstResult(firstResult).
                setMaxResults(maxResults).
                list(),
                rowCounter.getFoundRows());
        } finally {
            rowCounter.reset();
        }
    }

    public <T> PagedResponse<T> getPagedResponse(Query query, int firstResult, int maxResults) {
        rowCounter.setCalcFoundRows(true);
        try {
            @SuppressWarnings("unchecked")
            return new PagedResponse<T>(
                query.
                setFirstResult(firstResult).
                setMaxResults(maxResults).
                list(),
                rowCounter.getFoundRows());
        } finally {
            rowCounter.reset();
        }
    }
}

次に、文字列プロパティ "prop"を持つMyEntityという名前の@Entityの具体的なDAOクラスの例：

package my.hibernate.classes;

import org.hibernate.SessionFactory;
import org.hibernate.criterion.Restrictions
import org.springframework.beans.factory.annotation.Autowired;

public class MyEntityDAO extends BaseDAO {

    @Autowired
    private SessionFactory sessionFactory;

    public PagedResponse<MyEntity> getPagedEntitiesWithPropertyValue(String propVal, int firstResult, int maxResults) {
        return getPagedResponse(
            sessionFactory.
            getCurrentSession().
            createCriteria(MyEntity.class).
            add(Restrictions.eq("prop", propVal)),
            firstResult, 
            maxResults);
    }
}

最後に、すべての作業を行うインターセプタークラス：

package my.hibernate.classes;

import Java.io.IOException;
import Java.sql.Connection;
import Java.sql.ResultSet;
import Java.sql.SQLException;
import Java.sql.Statement;

import org.hibernate.EmptyInterceptor;
import org.hibernate.HibernateException;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.jdbc.Work;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;

public class MySQLCalcFoundRowsInterceptor extends EmptyInterceptor implements BeanFactoryAware {



    /**
     * 
     */
    private static final long serialVersionUID = 2745492452467374139L;

    //
    // Private statics
    //

    private final static String SELECT_PREFIX = "select ";

    private final static String CALC_FOUND_ROWS_HINT = "SQL_CALC_FOUND_ROWS ";

    private final static String SELECT_FOUND_ROWS = "select FOUND_ROWS()";

    //
    // Private members
    //
    private SessionFactory sessionFactory;

    private BeanFactory beanFactory;

    private String sessionFactoryBeanName;

    private ThreadLocal<Boolean> mCalcFoundRows = new ThreadLocal<Boolean>();

    private ThreadLocal<Integer> mSQLStatementsPrepared = new ThreadLocal<Integer>() {
        @Override
        protected Integer initialValue() {
            return Integer.valueOf(0);
        }
    };

    private ThreadLocal<Integer> mFoundRows = new ThreadLocal<Integer>();



    private void init() {
        if (sessionFactory == null) {
            if (sessionFactoryBeanName != null) {
                sessionFactory = beanFactory.getBean(sessionFactoryBeanName, SessionFactory.class);
            } else {
                try {
                    sessionFactory = beanFactory.getBean("sessionFactory", SessionFactory.class);
                } catch (RuntimeException exp) {

                }
                if (sessionFactory == null) {
                    sessionFactory = beanFactory.getBean(SessionFactory.class); 
                }
            }
        }
    }

    @Override
    public String onPrepareStatement(String sql) {
        if (mCalcFoundRows.get() == null || !mCalcFoundRows.get().booleanValue()) {
            return sql;
        }
        switch (mSQLStatementsPrepared.get()) {

        case 0: {
            mSQLStatementsPrepared.set(mSQLStatementsPrepared.get() + 1);

            // First time, prefix CALC_FOUND_ROWS_HINT

            StringBuilder builder = new StringBuilder(sql);
            int indexOf = builder.indexOf(SELECT_PREFIX);

            if (indexOf == -1) {
                throw new HibernateException("First SQL statement did not contain '" + SELECT_PREFIX + "'");
            }

            builder.insert(indexOf + SELECT_PREFIX.length(), CALC_FOUND_ROWS_HINT);
            return builder.toString();
        }

        case 1: {
            mSQLStatementsPrepared.set(mSQLStatementsPrepared.get() + 1);

            // Before any secondary selects, capture FOUND_ROWS. If no secondary
            // selects are
            // ever executed, getFoundRows() will capture FOUND_ROWS
            // just-in-time when called
            // directly

            captureFoundRows();
            return sql;
        }

        default:
            // Pass-through untouched
            return sql;
        }
    }

    public void reset() {
        if (mCalcFoundRows.get() != null && mCalcFoundRows.get().booleanValue()) {
            mSQLStatementsPrepared.remove();
            mFoundRows.remove();
            mCalcFoundRows.remove();
        }
    }

    @Override
    public void afterTransactionCompletion(Transaction tx) {
        reset();
    }

    public void setCalcFoundRows(boolean calc) {
        if (calc) {
            mCalcFoundRows.set(Boolean.TRUE);
        } else {
            reset();
        }
    }

    public int getFoundRows() {
        if (mCalcFoundRows.get() == null || !mCalcFoundRows.get().booleanValue()) {
            throw new IllegalStateException("Attempted to getFoundRows without first calling 'setCalcFoundRows'");
        }
        if (mFoundRows.get() == null) {
            captureFoundRows();
        }

        return mFoundRows.get();
    }

    //
    // Private methods
    //

    private void captureFoundRows() {
        init();

        // Sanity checks

        if (mFoundRows.get() != null) {
            throw new HibernateException("'" + SELECT_FOUND_ROWS + "' called more than once");
        }

        if (mSQLStatementsPrepared.get() < 1) {
            throw new HibernateException("'" + SELECT_FOUND_ROWS + "' called before '" + SELECT_PREFIX + CALC_FOUND_ROWS_HINT + "'");
        }

        // Fetch the total number of rows

        sessionFactory.getCurrentSession().doWork(new Work() {
            @Override
            public void execute(Connection connection) throws SQLException {
                final Statement stmt = connection.createStatement();
                ResultSet rs = null;
                try {
                    rs = stmt.executeQuery(SELECT_FOUND_ROWS);
                    if (rs.next()) {
                        mFoundRows.set(rs.getInt(1));
                    } else {
                        mFoundRows.set(0);
                    }
                } finally {
                    if (rs != null) {
                        rs.close();
                    }
                    try {
                        stmt.close();
                    } catch (RuntimeException exp) {

                    }
                }
            }
        });
    }

    public void setSessionFactoryBeanName(String sessionFactoryBeanName) {
        this.sessionFactoryBeanName = sessionFactoryBeanName;
    }

    @Override
    public void setBeanFactory(BeanFactory arg0) throws BeansException {
        this.beanFactory = arg0;
    }

}
6
Yinzara

総ページ数を表示する必要がない場合、カウントクエリが必要かどうかはわかりません。グーグルを含む多くのサイトは、ページングされた結果に合計を表示しません。代わりに、単に「次へ」と言います。

5
Kyle Dyer

MultiQuery を使用して、1回のデータベース呼び出しで両方のクエリを実行できます。これははるかに効率的です。 countクエリを生成することもできるため、毎回作成する必要はありません。ここに一般的なアイデアがあります...

var hql = "from Item where i.Age > :age"
var countHql = "select count(*) " + hql;

IMultiQuery multiQuery = _session.CreateMultiQuery()
    .Add(s.CreateQuery(hql)
            .SetInt32("age", 50).SetFirstResult(10))
    .Add(s.CreateQuery(countHql)
            .SetInt32("age", 50));

var results = multiQuery.List();
var items = (IList<Item>) results[0];
var count = (long)((IList<Item>) results[1])[0];

これをいくつかの使いやすいメソッドにまとめて、ページ付け可能なカウント可能なクエリを1行のコードで記述できるようにするのは簡単だと思います。

alternativeとして、 nhcontrib でNHibernateの作業中のLinqをテストする場合、あなたがこのようなことをすることができることを見つけてください：

var itemSpec = (from i in Item where i.Age > age);
var count = itemSpec.Count();
var list = itemSpec.Skip(10).Take(10).AsList();

明らかに、バッチ処理は行われていないため、それほど効率的ではありませんが、それでもニーズに合う可能性がありますか？

お役に立てれば！

3
tobinharris

やり方がある

mysql> SELECT SQL_CALC_FOUND_ROWS * FROM tbl_name
    -> WHERE id > 100 LIMIT 10;
mysql> SELECT FOUND_ROWS();

2番目のSELECTは、最初のSELECTがLIMIT句なしで書き込まれた場合に返すはずの行数を示す数値を返します。

リファレンス： FOUND_ROWS（）

2
michal kralik

私はこの問題を知っており、以前に直面したことがあります。まず、同じSELECT条件を実行する二重クエリメカニズムは、実際には最適ではありません。しかし、それは機能し、あなたが外に出て大きな変更を行う前に、それが価値がないかもしれないことを理解してください。

しかし、とにかく：

1）クライアント側で小さなデータを処理する場合は、結果セットの実装を使用して、カーソルをセットの最後に設定し、その行オフセットを取得してから、カーソルを最初にリセットします。

2）クエリを再設計して、通常の行の追加の列としてCOUNT（*）を取得します。はい、すべての行に同じ値が含まれていますが、整数である追加の列が1つだけ含まれています。これは、集計値を非集計値で表すには不適切なSQLですが、機能する場合があります。

3）言及されているものと同様に、推定制限を使用するようにクエリを再設計します。ページあたりの行数と上限を使用します。例えば。 「500以上の1〜10を表示する」のように言ってください。彼らが「Xの25oから260を表示」を参照するときは、それ以降のクエリなので、ページ*行/ページに相対的な上限を設定することで、Xの見積もりを更新できます。

2
Josh

ソリューションは使用しているデータベースに依存すると思います。たとえば、MS SQLと次のクエリを使用しています

select 
  COUNT(Table.Column) OVER() as TotalRowsCount,
  Table.Column,
  Table.Column2
from Table ...

クエリのその部分は、データベース指定のSQLで変更できます。

また、予想されるクエリの最大結果を設定します。

query.setMaxResults(pageNumber * itemsPerPage)

クエリ実行の結果としてScrollableResultsインスタンスを取得します。

ScrollableResults result = null;
try {
    result = query.scroll();
    int totalRowsNumber = result.getInteger(0);
    int from = // calculate the index of row to get for the expected page if any

    /*
     * Reading data form page and using Transformers.ALIAS_TO_ENTITY_MAP
     * to make life easier.
     */ 
}
finally {
    if (result != null) 
        result.close()
}
1
ruslan

このHibernate wikiページ：

https://www.hibernate.org/314.html

私は完全なページ分割ソリューションを提示します。特に、要素の総数は、結果セットの最後までスクロールして計算されます。これは、現在いくつかのJDBCドライバーでサポートされています。これにより、2番目の「カウント」クエリが回避されます。

1
Pietro Polsinelli

これが解決策です リチャードケナード博士（ブログのコメントでバグ修正にご注意ください！）、 Hibernate Interceptors を使用

要約すると、インターセプターが後で見つかった行の数を提供できるように、sessionFactoryをインターセプタークラスにバインドします。

ソリューションリンクでコードを見つけることができます。以下は使用例です。

SessionFactory sessionFactory = ((org.hibernate.Session) mEntityManager.getDelegate()).getSessionFactory();
MySQLCalcFoundRowsInterceptor foundRowsInterceptor = new MySQLCalcFoundRowsInterceptor( sessionFactory );
Session session = sessionFactory.openSession( foundRowsInterceptor );

try {
   org.hibernate.Query query = session.createQuery( ... )   // Note: JPA-QL, not createNativeQuery!
   query.setFirstResult( ... );
   query.setMaxResults( ... );

   List entities = query.list();
   long foundRows = foundRowsInterceptor.getFoundRows();

   ...

} finally {

   // Disconnect() is good practice, but close() causes problems. Note, however, that
   // disconnect could lead to lazy-loading problems if the returned list of entities has
   // lazy relations

   session.disconnect();
}
0
kommradHomer

大きなデータセットサイズで選択カウント（*）を実行せずに休止状態でページングを行う方法を見つけました。ここに私の答えのために投稿したソリューションを見てください。

ページングによる多数のデータベースエントリの処理は時間とともに遅くなります

最初に必要なページ数を知らなくても、一度に1つずつページングを実行できます。

0
randomThought