@Override public String processSql(String sql, RowSelection selection) { final boolean hasOffset = LimitHelper.hasFirstRow( selection ); return sql + (hasOffset ? " limit ?, ?" : " limit ?"); }
@Override public String processSql(String sql, RowSelection selection) { final String soff = " offset " + selection.getFirstRow(); final String slim = " fetch first " + getMaxOrLimit( selection ) + " rows only"; final StringBuilder sb = new StringBuilder( sql.length() + soff.length() + slim.length() ) .append( sql ); if (LimitHelper.hasFirstRow( selection )) { sb.append( soff ); } if (LimitHelper.hasMaxRows( selection )) { sb.append( slim ); } return sb.toString(); }
@Override public String processSql(String sql, RowSelection selection) { final boolean useLimitOffset = supportsLimit() && supportsLimitOffset() && LimitHelper.hasFirstRow( selection ) && LimitHelper.hasMaxRows( selection ); return dialect.getLimitString( sql, useLimitOffset ? LimitHelper.getFirstRow( selection ) : 0, getMaxOrLimit( selection ) ); } }
@Override public String processSql(String sql, RowSelection selection) { if (LimitHelper.useLimit( this, selection )) { return sql + (LimitHelper.hasFirstRow( selection ) ? " offset ? rows fetch next ? rows only" : " fetch first ? rows only"); } else { // or return unaltered SQL return sql; } }
@Override public void setMaxRows(RowSelection selection, PreparedStatement statement) throws SQLException { if ( LimitHelper.hasMaxRows( selection ) ) { int maxRows = selection.getMaxRows() + convertToFirstRowValue( LimitHelper.getFirstRow( selection ) ); // Use Integer.MAX_VALUE on overflow if ( maxRows < 0 ) { statement.setMaxRows( Integer.MAX_VALUE ); } else { statement.setMaxRows( maxRows ); } } } }
/** * Should limit be applied? * * @param limitHandler The limit handler * @param selection The row selection * * @return Whether limiting is indicated */ public static boolean useLimit(LimitHandler limitHandler, RowSelection selection) { return limitHandler.supportsLimit() && hasMaxRows( selection ); }
/** * Build LIMIT clause handler applicable for given selection criteria. Returns {@link NoopLimitHandler} delegate * if dialect does not support LIMIT expression or processed query does not use pagination. * * @param selection Selection criteria. * * @return LIMIT clause delegate. */ protected LimitHandler getLimitHandler(RowSelection selection) { final LimitHandler limitHandler = getFactory().getDialect().getLimitHandler(); return LimitHelper.useLimit( limitHandler, selection ) ? limitHandler : NoopLimitHandler.INSTANCE; }
/** * Is a first row limit indicated? * * @param selection The row selection options * * @return Whether a first row limit in indicated */ public static boolean hasFirstRow(RowSelection selection) { return getFirstRow( selection ) > 0; }
@Override public String processSql(String sql, RowSelection selection) { if ( LimitHelper.useLimit( this, selection ) ) { // useLimitOffset: whether "offset" is set or not; // if set, use "LIMIT offset, row_count" syntax; // if not, use "LIMIT row_count" final boolean useLimitOffset = LimitHelper.hasFirstRow( selection ); return sql + (useLimitOffset ? " limit ?, ?" : " limit ?"); } else { // or return unaltered SQL return sql; } } }
/** * Default implementation of binding parameter values needed by the LIMIT clause. * * @param selection the selection criteria for rows. * @param statement Statement to which to bind limit parameter values. * @param index Index from which to start binding. * @return The number of parameter values bound. * @throws SQLException Indicates problems binding parameter values. */ protected final int bindLimitParameters(RowSelection selection, PreparedStatement statement, int index) throws SQLException { if ( !supportsVariableLimit() || !LimitHelper.hasMaxRows( selection ) ) { return 0; } final int firstRow = convertToFirstRowValue( LimitHelper.getFirstRow( selection ) ); final int lastRow = getMaxOrLimit( selection ); final boolean hasFirstRow = supportsLimitOffset() && ( firstRow > 0 || forceLimitUsage() ); final boolean reverse = bindLimitParametersInReverseOrder(); if ( hasFirstRow ) { statement.setInt( index + ( reverse ? 1 : 0 ), firstRow ); } statement.setInt( index + ( reverse || !hasFirstRow ? 0 : 1 ), lastRow ); return hasFirstRow ? 2 : 1; }
if ( LimitHelper.hasMaxRows( selection ) ) { maxRows = selection.getMaxRows(); LOG.tracef( "Limiting ResultSet processing to just %s rows", maxRows );
/** * Build LIMIT clause handler applicable for given selection criteria. Returns {@link org.hibernate.dialect.pagination.NoopLimitHandler} delegate * if dialect does not support LIMIT expression or processed query does not use pagination. * * @param selection Selection criteria. * @return LIMIT clause delegate. */ protected LimitHandler getLimitHandler(RowSelection selection) { final LimitHandler limitHandler = getFactory().getDialect().getLimitHandler(); return LimitHelper.useLimit( limitHandler, selection ) ? limitHandler : NoopLimitHandler.INSTANCE; }
/** * Advance the cursor to the first required row of the <tt>ResultSet</tt> */ protected void advance(final ResultSet rs, final RowSelection selection) throws SQLException { final int firstRow = LimitHelper.getFirstRow( selection ); if ( firstRow != 0 ) { if ( getFactory().getSettings().isScrollableResultSetsEnabled() ) { // we can go straight to the first required row rs.absolute( firstRow ); } else { // we need to step through the rows one row at a time (slow) for ( int m = 0; m < firstRow; m++ ) { rs.next(); } } } }
@Override public String processSql(String sql, RowSelection selection) { final boolean hasOffset = LimitHelper.hasFirstRow( selection ); return sql + ( hasOffset ? " limit ? offset ?" : " limit ?" ); }
@Override public String processSql(String sql, RowSelection selection) { final String soff = " offset " + selection.getFirstRow(); final String slim = " fetch first " + getMaxOrLimit( selection ) + " rows only"; final StringBuilder sb = new StringBuilder( sql.length() + soff.length() + slim.length() ) .append( sql ); if (LimitHelper.hasFirstRow( selection )) { sb.append( soff ); } if (LimitHelper.hasMaxRows( selection )) { sb.append( slim ); } return sb.toString(); }
final Dialect dialect = getFactory().getDialect(); final RowSelection selection = queryParameters.getRowSelection(); final boolean useLimit = LimitHelper.useLimit( limitHandler, selection ); final boolean hasFirstRow = LimitHelper.hasFirstRow( selection ); final boolean useLimitOffset = hasFirstRow && useLimit && limitHandler.supportsLimitOffset(); final boolean callable = queryParameters.isCallable();
@Override public String processSql(String sql, RowSelection selection) { final boolean useLimitOffset = supportsLimit() && supportsLimitOffset() && LimitHelper.hasFirstRow( selection ) && LimitHelper.hasMaxRows( selection ); return dialect.getLimitString( sql, useLimitOffset ? LimitHelper.getFirstRow( selection ) : 0, getMaxOrLimit( selection ) ); } }
@Override public void setMaxRows(RowSelection selection, PreparedStatement statement) throws SQLException { if ( LimitHelper.hasMaxRows( selection ) ) { int maxRows = selection.getMaxRows() + convertToFirstRowValue( LimitHelper.getFirstRow( selection ) ); // Use Integer.MAX_VALUE on overflow if ( maxRows < 0 ) { statement.setMaxRows( Integer.MAX_VALUE ); } else { statement.setMaxRows( maxRows ); } } } }
private void doTheLoad(String sql, QueryParameters queryParameters, SharedSessionContractImplementor session) throws SQLException { final RowSelection selection = queryParameters.getRowSelection(); final int maxRows = LimitHelper.hasMaxRows( selection ) ? selection.getMaxRows() : Integer.MAX_VALUE; final List<AfterLoadAction> afterLoadActions = Collections.emptyList(); final SqlStatementWrapper wrapper = executeQueryStatement( sql, queryParameters, false, afterLoadActions, session ); final ResultSet rs = wrapper.getResultSet(); final Statement st = wrapper.getStatement(); try { processResultSet( rs, queryParameters, session, true, null, maxRows, afterLoadActions ); } finally { session.getJdbcCoordinator().getLogicalConnection().getResourceRegistry().release( st ); session.getJdbcCoordinator().afterStatementExecution(); } }
@Override public String processSql(String sql, RowSelection selection) { // SQLServer mandates the following rules to use OFFSET/LIMIT // * An 'ORDER BY' is required // * The 'OFFSET ...' clause is mandatory, cannot use 'FETCH ...' by itself. // * The 'TOP' clause isn't permitted with LIMIT/OFFSET. if ( hasOrderBy( sql ) ) { if ( !LimitHelper.useLimit( this, selection ) ) { return sql; } return applyOffsetFetch( selection, sql, getInsertPosition( sql ) ); } return super.processSql( sql, selection ); }