Package org.hibernate.dialect.pagination

Class AbstractLimitHandler

java.lang.Object
org.hibernate.dialect.pagination.AbstractLimitHandler
All Implemented Interfaces:
LimitHandler
Direct Known Subclasses:
AbstractNoOffsetLimitHandler, AbstractSimpleLimitHandler, LegacyDB2LimitHandler, NoopLimitHandler, OffsetFetchLimitHandler, Oracle12LimitHandler
public abstract class AbstractLimitHandler extends Object implements LimitHandler
Default implementation of LimitHandler interface.

  • Field Details

  • Constructor Details

    • AbstractLimitHandler

      public AbstractLimitHandler()

  • Method Details

    • supportsLimit

      public boolean supportsLimit()
      Description copied from interface: LimitHandler
      Does this handler support limiting query results?
      Specified by:
      supportsLimit in interface LimitHandler
      Returns:
      True if this handler supports limit alone.

    • supportsOffset

      public boolean supportsOffset()
      Description copied from interface: LimitHandler
      Does this handler support offsetting query results without also specifying a limit?
      Specified by:
      supportsOffset in interface LimitHandler
      Returns:
      True if this handler supports offset alone.

    • supportsLimitOffset

      public boolean supportsLimitOffset()
      Description copied from interface: LimitHandler
      Does this handler support combinations of limit and offset?
      Specified by:
      supportsLimitOffset in interface LimitHandler
      Returns:
      True if the handler supports an offset within the limit support.

    • supportsVariableLimit

      public boolean supportsVariableLimit()
      Does this handler support bind variables (JDBC prepared statement parameters) for its limit/offset?
      Returns:
      true if bind variables can be used

    • bindLimitParametersInReverseOrder

      public boolean bindLimitParametersInReverseOrder()
      Usually, the offset comes before the limit, but occasionally the offset is specified after the limit. Does this dialect require us to bind the parameters in reverse order?
      Returns:
      true if the correct order is limit then offset

    • bindLimitParametersFirst

      public boolean bindLimitParametersFirst()
      Does the offset/limit clause come at the start of the SELECT statement, or at the end of the query?
      Returns:
      true if limit parameters come before other parameters

    • useMaxForLimit

      public boolean useMaxForLimit()
      Does the limit clause expect the number of the last row, or the "page size", the maximum number of rows we want to receive? Hibernate's Query.setMaxResults(int) accepts the page size, so the number of the last row is obtained by adding the number of the first row, which is one greater than Query.setFirstResult(int).
      Returns:
      true if the limit clause expects the number of the last row, false if it expects the page size

    • forceLimitUsage

      public boolean forceLimitUsage()
      Generally, if there is no limit applied to a Hibernate query we do not apply any limits to the SQL query. This option forces that the limit be written to the SQL query.
      Returns:
      true to force limit into SQL query even if none specified in Hibernate query; false otherwise.

    • convertToFirstRowValue

      public int convertToFirstRowValue(int zeroBasedFirstResult)
      The API method Query.setFirstResult(int) accepts a zero-based offset. Does this dialect require a one-based offset to be specified in the offset clause?
      Parameters:
      zeroBasedFirstResult - The user-supplied, zero-based first row offset.
      Returns:
      The resulting offset, adjusted to one-based if necessary.
      Implementation Note:
      The value passed into processSql(String, Limit) has a zero-based offset. Handlers which do not supportsVariableLimit() should take care to perform any needed first-row-conversion calls prior to injecting the limit values into the SQL string.

    • processSql

      public String processSql(String sql, Limit limit)
      Specified by:
      processSql in interface LimitHandler

    • bindLimitParametersAtStartOfQuery

      public int bindLimitParametersAtStartOfQuery(Limit limit, PreparedStatement statement, int index) throws SQLException
      Specified by:
      bindLimitParametersAtStartOfQuery in interface LimitHandler
      Throws:
      SQLException

    • bindLimitParametersAtEndOfQuery

      public int bindLimitParametersAtEndOfQuery(Limit limit, PreparedStatement statement, int index) throws SQLException
      Specified by:
      bindLimitParametersAtEndOfQuery in interface LimitHandler
      Throws:
      SQLException

    • setMaxRows

      public void setMaxRows(Limit limit, PreparedStatement statement) throws SQLException
      Specified by:
      setMaxRows in interface LimitHandler
      Throws:
      SQLException

    • bindLimitParameters

      protected final int bindLimitParameters(Limit limit, PreparedStatement statement, int index) throws SQLException
      Default implementation of binding parameter values needed by the LIMIT clause.
      Parameters:
      limit - the limit.
      statement - Statement to which to bind limit parameter values.
      index - Index from which to start binding.
      Returns:
      The number of parameter values bound.
      Throws:
      SQLException - Indicates problems binding parameter values.

    • hasMaxRows

      public static boolean hasMaxRows(Limit limit)
      Is a max row limit indicated?
      Parameters:
      limit - The limit
      Returns:
      Whether a max row limit was indicated

    • hasFirstRow

      public static boolean hasFirstRow(Limit limit)
      Is a first row limit indicated?
      Parameters:
      limit - The limit
      Returns:
      Whether a first row limit was indicated

    • getMaxOrLimit

      protected final int getMaxOrLimit(Limit limit)
      Some dialect-specific LIMIT clauses require the maximum last row number (aka, first_row_number + total_row_count), while others require the maximum returned row count (the total maximum number of rows to return).
      Parameters:
      limit - The limit
      Returns:
      The appropriate value to bind into the limit clause.

    • getFirstRow

      protected final int getFirstRow(Limit limit)
      Retrieve the indicated first row for pagination
      Parameters:
      limit - The limit
      Returns:
      The first row

    • insertAfterSelect

      protected static String insertAfterSelect(String limitOffsetClause, String sqlStatement)
      Insert a fragment of SQL right after SELECT, but before DISTINCT or ALL.

    • insertAfterDistinct

      protected static String insertAfterDistinct(String limitOffsetClause, String sqlStatement)
      Insert a fragment of SQL right after SELECT, SELECT DISTINCT, or SELECT ALL.

    • insertAtEnd

      protected String insertAtEnd(String limitOffsetClause, String sqlStatement)
      Insert a fragment of SQL right at the very end of the query.

    • getForUpdatePattern

      protected Pattern getForUpdatePattern()
      The offset/limit clauses typically must come before the FOR UPDATEish clauses, so we need a way to identify these clauses in the text of the whole query.

    • insertBeforeForUpdate

      protected String insertBeforeForUpdate(String limitOffsetClause, String sqlStatement)
      Insert a fragment of SQL right before the FOR UPDATEish clauses at the end of the query.