title |
---|
Pagy::Countless |
This is a Pagy
subclass that provides pagination without the need of any :count
. That may be especially useful in the following scenarios:
- slow
COUNT(*)
query - result of large tables or poorly optimized DBs - large collections of items where the count is missing or irrelevant
- minimalistic UI, infinite scrolling, APIs that don't benefit from a nav-bar
- when the full nav-bar is not a requirement and/or performance is more desirable
This class is providing support for extras that don't need the full set of pagination support or need to avoid the :count
variable (e.g. the countless extra). You should not need to use it directly because it is required and used internally.
In this class the :count
variable is always nil
, hence some feature that depends on it may have limited or no support:
The nav bar links after the current page cannot be fully displayed because a couple if items of the :size
array depends on the count
, so they have some limitations.
Regardless the actual :size
value:
vars[:size][2]
is capped at 1 (we know only if the next page exists)vars[:size][3]
is set to 0 (we don't know the total pages)
A few examples:
[1,4,4,1]
would be treated like[ 1,4,1,0]
[1,4,3,4]
would be treated like[ 1,4,1,0]
[1,4,0,0]
would be treated like[ 1,4,0,0]
The series
method reflects on the above.
The available values for the :overflow
variable are :empty_page
and :exception
, missing the :last_page
(which is not known in case of an exception).
The pagy_info
and all the *_combo_nav_js
helpers that use the total count
are not supported.
Instead of basing all the internal calculations on the :count
variable (passed with the constructor), this class uses the number of actually retrieved items to deduce the pagination variables.
The retrieved items number is passed in a second step with the finalize
method, and it allows to determine if there is a next
page, or if the current page is the last
page, or if the current request should raise a Pagy::OverflowError
exception.
The trick is retrieving items + 1
, and using the resulting number to calculate the variables, while eventually removing the extra item from the result. (see the countless.rb extra)
The construction of the final Pagy::Countless
object is splitted into 2 steps: the regular initialize
method and the finalize
method, which will use the retrieved items number to calculate the rest of the pagination integers.
The initial constructor takes the usual hash of variables, calculating only the requested items
and the offset
, useful to query the page of items.
The actual calculation of all the internal variables for the pagination is calculated using the number of fetched
items. The method returns the finalized instance object.