org.hibernate.dialect.pagination.LimitHandler Java Examples

default CompletionStage<ResultSet> executeReactiveQueryStatement(
		String sqlStatement,
		QueryParameters queryParameters,
		List<AfterLoadAction> afterLoadActions,
		SessionImplementor session) {

	// Processing query filters.
	queryParameters.processFilters( sqlStatement, session );

	// Applying LIMIT clause.
	final LimitHandler limitHandler = limitHandler( queryParameters.getRowSelection(), session );
	String sql = limitHandler.processSql( queryParameters.getFilteredSQL(), queryParameters.getRowSelection() );

	// Adding locks and comments.
	sql = preprocessSQL( sql, queryParameters, session.getSessionFactory(), afterLoadActions );

	return session.unwrap(ReactiveSession.class)
			.getReactiveConnection()
			.selectJdbc( sql, toParameterArray(queryParameters, session) );
}
 

/**
 * Execute given <tt>PreparedStatement</tt>, advance to the first result and return SQL <tt>ResultSet</tt>.
 */
protected final ResultSet getResultSet(
		final PreparedStatement st,
		final RowSelection selection,
		final LimitHandler limitHandler,
		final boolean autodiscovertypes,
		final SharedSessionContractImplementor session) throws SQLException, HibernateException {
	try {
		ResultSet rs = session.getJdbcCoordinator().getResultSetReturn().extract( st );

		return processResultSet(rs, selection, limitHandler, autodiscovertypes, session);
	}
	catch (SQLException | HibernateException e) {
		session.getJdbcCoordinator().getLogicalConnection().getResourceRegistry().release( st );
		session.getJdbcCoordinator().afterStatementExecution();
		throw e;
	}
}
 

/**
 * Execute given <tt>CallableStatement</tt>, advance to the first result and return SQL <tt>ResultSet</tt>.
 */
protected final ResultSet getResultSet(
		final CallableStatement st,
		final RowSelection selection,
		final LimitHandler limitHandler,
		final boolean autodiscovertypes,
		final SharedSessionContractImplementor session) throws SQLException, HibernateException {
	try {
		ResultSet rs = session.getJdbcCoordinator().getResultSetReturn().extract( st );

		return processResultSet(rs, selection, limitHandler, autodiscovertypes, session);
	}
	catch (SQLException | HibernateException e) {
		session.getJdbcCoordinator().getLogicalConnection().getResourceRegistry().release( st );
		session.getJdbcCoordinator().afterStatementExecution();
		throw e;
	}
}
 

private ResultSet processResultSet(
		ResultSet rs,
		final RowSelection selection,
		final LimitHandler limitHandler,
		final boolean autodiscovertypes,
		final SharedSessionContractImplementor session
) throws SQLException, HibernateException {
	rs = wrapResultSetIfEnabled( rs, session );

	if ( !limitHandler.supportsLimitOffset() || !LimitHelper.useLimit( limitHandler, selection ) ) {
		advance( rs, selection );
	}

	if ( autodiscovertypes ) {
		autoDiscoverTypes( rs );
	}
	return rs;
}
 

/**
 * Execute given <tt>PreparedStatement</tt>, advance to the first result and return SQL <tt>ResultSet</tt>.
 */
protected final ResultSet getResultSet(
		final PreparedStatement st,
		final RowSelection selection,
		final LimitHandler limitHandler,
		final boolean autodiscovertypes,
		final SharedSessionContractImplementor session)
		throws SQLException, HibernateException {

	try {
		ResultSet rs = session.getJdbcCoordinator().getResultSetReturn().extract( st );
		rs = wrapResultSetIfEnabled( rs , session );

		if ( !limitHandler.supportsLimitOffset() || !LimitHelper.useLimit( limitHandler, selection ) ) {
			advance( rs, selection );
		}

		if ( autodiscovertypes ) {
			autoDiscoverTypes( rs );
		}
		return rs;
	}
	catch (SQLException | HibernateException ex) {
		session.getJdbcCoordinator().getResourceRegistry().release( st );
		session.getJdbcCoordinator().afterStatementExecution();
		throw ex;
	}
}
 

@Override
public LimitHandler getLimitHandler() {
	if ( isLegacyLimitHandlerBehaviorEnabled() ) {
		return LegacyFirstLimitHandler.INSTANCE;
	}
	return getDefaultLimitHandler();
}
 

@Override
public LimitHandler getLimitHandler() {
	if ( isLegacyLimitHandlerBehaviorEnabled() ) {
		return LegacyFirstLimitHandler.INSTANCE;
	}
	return FirstLimitHandler.INSTANCE;
}
 

@Override
public LimitHandler getLimitHandler() {
	if ( isLegacyLimitHandlerBehaviorEnabled() ) {
		return super.getLimitHandler();
	}
	return limitHandler;
}
 

@Override
public LimitHandler getLimitHandler() {
	if ( isLegacyLimitHandlerBehaviorEnabled() ) {
		return LegacyFirstLimitHandler.INSTANCE;
	}
	return FirstLimitHandler.INSTANCE;
}
 

@Override
public LimitHandler getLimitHandler() {
	if ( isLegacyLimitHandlerBehaviorEnabled() ) {
		return new LegacyLimitHandler( this );
	}
	return getDefaultLimitHandler();
}
 

@Override
public LimitHandler getLimitHandler() {
	if ( isLegacyLimitHandlerBehaviorEnabled() ) {
		return LEGACY_LIMIT_HANDLER;
	}
	return LIMIT_HANDLER;
}
 

@Override
public LimitHandler getLimitHandler() {
	if ( isLegacyLimitHandlerBehaviorEnabled() ) {
		return LEGACY_LIMIT_HANDLER;
	}
	else {
		return LIMIT_HANDLER;
	}
}
 

@Override
public void bindToPreparedStatement(PreparedStatement adaptor,
									QueryParameters queryParameters,
									LimitHandler limitHandler,
									SharedSessionContractImplementor session) throws SQLException {
	super.bindPreparedStatement(adaptor, queryParameters, limitHandler, session);
}
 

@Override
public void bindToPreparedStatement(PreparedStatement adaptor,
									QueryParameters queryParameters,
									LimitHandler limitHandler,
									SharedSessionContractImplementor session) throws SQLException {
	super.bindPreparedStatement(adaptor, queryParameters, limitHandler, session);
}
 

protected SqlStatementWrapper executeQueryStatement(
		String sqlStatement,
		QueryParameters queryParameters,
		boolean scroll,
		List<AfterLoadAction> afterLoadActions,
		SharedSessionContractImplementor session) throws SQLException {

	// Processing query filters.
	queryParameters.processFilters( sqlStatement, session );

	// Applying LIMIT clause.
	final LimitHandler limitHandler = getLimitHandler(
			queryParameters.getRowSelection()
	);
	String sql = limitHandler.processSql( queryParameters.getFilteredSQL(), queryParameters.getRowSelection() );

	// Adding locks and comments.
	sql = session.getJdbcServices().getJdbcEnvironment().getDialect()
			.addSqlHintOrComment(
				sql,
				queryParameters,
				session.getFactory().getSessionFactoryOptions().isCommentsEnabled()
			);

	final PreparedStatement st = prepareQueryStatement( sql, queryParameters, limitHandler, scroll, session );
	return new SqlStatementWrapper( st, getResultSet( st, queryParameters.getRowSelection(), limitHandler, queryParameters.hasAutoDiscoverScalarTypes(), session ) );
}
 

@Test
public void testLimit() {
    final RowSelection rowSelection = new RowSelection();
    rowSelection.setMaxRows(getMaxRows());
    LimitHandler limitHandler = ((SessionFactoryImpl) sessionFactory()).getDialect().getLimitHandler();
    String limitStatement = limitHandler.processSql(SELECT_POST_COMMENT, rowSelection);
    long startNanos = System.nanoTime();
    doInJDBC(connection -> {
        try (PreparedStatement statement = connection.prepareStatement(limitStatement)) {
            limitHandler.bindLimitParametersAtEndOfQuery(rowSelection, statement, 1);
            statement.setInt(1, getMaxRows());
            statement.execute();
            int count = 0;
            ResultSet resultSet = statement.getResultSet();
            while (resultSet.next()) {
                resultSet.getLong(1);
                count++;
            }
            assertEquals(getMaxRows(), count);
        } catch (SQLException e) {
            fail(e.getMessage());
        }

    });
    LOGGER.info("{} Result Set with limit took {} millis",
            dataSourceProvider().database(),
            TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startNanos));
}
 

protected LimitHandler getDefaultLimitHandler() {
	return limitHandler;
}
 

@Override
public LimitHandler getLimitHandler() {
	return LIMIT_HANDLER;
}
 

@Override
public LimitHandler getLimitHandler() {
    return SQL2008StandardLimitHandler.INSTANCE;
}
 

@Override
public LimitHandler getLimitHandler() {
    return new Oracle9iDialect().getLimitHandler();
}
 

@Override
public LimitHandler getLimitHandler() {
	return Informix10LimitHandler.INSTANCE;
}
 

@Override
public LimitHandler getLimitHandler() {
	return LIMIT_HANDLER;
}
 

@Override
public LimitHandler getLimitHandler() {
    return SQL2008StandardLimitHandler.INSTANCE;
}
 

@Override
protected LimitHandler getDefaultLimitHandler() {
	return new SQLServer2012LimitHandler();
}
 

@Override
public LimitHandler getLimitHandler() {
    return SQL2008StandardLimitHandler.INSTANCE;
}
 

@Override
protected LimitHandler getDefaultLimitHandler() {
	return new SQLServer2005LimitHandler();
}
 

@Override
public LimitHandler getLimitHandler() {
	return LIMIT_HANDLER;
}
 

@Override
public LimitHandler getLimitHandler() {
    return getInstance().getLimitHandler();
}
 

@Override
public LimitHandler getLimitHandler() {
	return LIMIT_HANDLER;
}
 

@Override
public LimitHandler getLimitHandler() {
	return LIMIT_HANDLER;
}