Question

我有这个设置

@Table(name ="A")
EntityA {
    Long ID;
    List<EntityB> children;
}

@Table(name ="B")
EntityB {
    Long ID;
    EntityA parent;
    EntityC grandchild;
}

@Table(name ="C")
EntityC {
    Long ID;
}

SQL查询是这样的（我省略了不相关的细节）：

select top 300 from A where ... and ID in (select parent from B where ... and grandchild in (select ID from C where ...)) order by ...

直接数据库中的sql查询或通过Hibernate（3.5）SQL运行速度比使用Criteria或HQL表达速度快1000倍。

从HQL和Criteria以及我在那里发布的SQL中生成的SQL 相同。

[编辑]：更正 - sql不完全相同。我没有在管理工作室方面尝试Hibernate样式参数设置，因为直到后来我才意识到这一点 - 请参阅我的回答。

如果我将子查询分成单独的查询，那么它又快了。

我试过

删除子，父，等的所有映射...并且只使用Long Id引用 - 同样的事情，所以它不是一个吸引人的，懒惰的，渴望相关的。
使用连接而不是子查询，并且在获取和加载的所有组合中获得了相同的缓慢行为。
在ID上设置投影而不是检索实体，因此没有对象转换 - 仍然很慢

我查看了Hibernate代码，它正在做一些惊人的事情。它有一个循环遍历所有300个结果，最终命中数据库。

private List doQuery(
        final SessionImplementor session,
        final QueryParameters queryParameters,
        final boolean returnProxies) throws SQLException, HibernateException {

    final RowSelection selection = queryParameters.getRowSelection();
    final int maxRows = hasMaxRows( selection ) ?
            selection.getMaxRows().intValue() :
            Integer.MAX_VALUE;

    final int entitySpan = getEntityPersisters().length;

    final ArrayList hydratedObjects = entitySpan == 0 ? null : new ArrayList( entitySpan * 10 );
    final PreparedStatement st = prepareQueryStatement( queryParameters, false, session );
    final ResultSet rs = getResultSet( st, queryParameters.hasAutoDiscoverScalarTypes(), queryParameters.isCallable(), selection, session );

// would be great to move all this below here into another method that could also be used
// from the new scrolling stuff.
//
// Would need to change the way the max-row stuff is handled (i.e. behind an interface) so
// that I could do the control breaking at the means to know when to stop

    final EntityKey optionalObjectKey = getOptionalObjectKey( queryParameters, session );
    final LockMode[] lockModesArray = getLockModes( queryParameters.getLockOptions() );
    final boolean createSubselects = isSubselectLoadingEnabled();
    final List subselectResultKeys = createSubselects ? new ArrayList() : null;
    final List results = new ArrayList();

    try {

        handleEmptyCollections( queryParameters.getCollectionKeys(), rs, session );

        EntityKey[] keys = new EntityKey[entitySpan]; //we can reuse it for each row

        if ( log.isTraceEnabled() ) log.trace( "processing result set" );

        int count;
        for ( count = 0; count < maxRows && rs.next(); count++ ) {

            if ( log.isTraceEnabled() ) log.debug("result set row: " + count);

            Object result = getRowFromResultSet( 
                    rs,
                    session,
                    queryParameters,
                    lockModesArray,
                    optionalObjectKey,
                    hydratedObjects,
                    keys,
                    returnProxies 
            );
            results.add( result );

            if ( createSubselects ) {
                subselectResultKeys.add(keys);
                keys = new EntityKey[entitySpan]; //can't reuse in this case
            }

        }

        if ( log.isTraceEnabled() ) {
            log.trace( "done processing result set (" + count + " rows)" );
        }

    }
    finally {
        session.getBatcher().closeQueryStatement( st, rs );
    }

    initializeEntitiesAndCollections( hydratedObjects, rs, session, queryParameters.isReadOnly( session ) );

    if ( createSubselects ) createSubselects( subselectResultKeys, queryParameters, session );

    return results; //getResultList(results);

}

在此代码中

final ResultSet rs = getResultSet( st, queryParameters.hasAutoDiscoverScalarTypes(), queryParameters.isCallable(), selection, session );

它使用完整的SQL命中数据库，但在任何地方都没有收集任何结果。

然后继续进行此循环

for ( count = 0; count < maxRows && rs.next(); count++ ) {

对于预期的300个结果中的每一个，它最终会到达数据库以获得实际结果。

这看起来很疯狂，因为在1次查询后它应该已经有了所有结果。 Hibernate日志不显示在此期间发布的任何其他SQL。

任何人都有任何见解？我唯一的选择是通过Hibernate转到本机SQL查询。

Answer 1

我终于成功了解了这一点。问题是由Hibernate将参数与涉及子查询的实际SQL查询分开设置引起的。如此原生SQL，如果这样做，性能将会很慢。例如，这将是缓慢的：

String sql = some sql that has named parameter = :value
SQLQuery sqlQuery = session.createSQLQuery(sql);
sqlQuery.setParameter ("value", someValue);
List<Object[]> list = (List<Object[]>)sqlQuery.list();

这将很快

String sql = some native sql where parameter = 'actualValue'
SQLQuery sqlQuery = session.createSQLQuery(sql);
List<Object[]> list = (List<Object[]>)sqlQuery.list();

似乎由于某些原因让Hibernate处理参数，它最终会被卡在resultSet中。这可能是因为数据库的基础查询花费了更长的时间进行参数化。我最终编写了相当于Hibernate Criteria和Restrictions代码的代码，它直接按上述方式设置参数。

Answer 2

我们注意到系统中存在类似的行为。

还遇到了使用硬编码参数而不是使用setParameter()编写查询将解决此问题的情况。

我们正在使用 MS SQL Server ，经过进一步调查，我们注意到问题的根本原因是sql服务器驱动程序的默认配置，该配置将查询参数作为unicode传输。这导致我们的索引被忽略，因为它们基于查询列上的ascii值。

解决方案是在jdbc url中设置此属性：sendStringParametersAsUnicode = false

更多详细信息可以在这里找到。 https://stackoverflow.com/a/32867579

Hibernate比sql查询慢{1000}

2 个答案: