Struct Pagination 

pub struct Pagination {
    pub page: usize,
    pub limit: usize,
    pub max_limit: usize,
}

A builder for pagination settings.

Use this struct to define how results should be paginated before executing a query via paginate().

Fields

page: usize

Zero-based page index

limit: usize

Number of items per page

max_limit: usize

Maximum allowed items per page (safety limit)

Implementations

impl Pagination

pub fn new_with_limit(page: usize, limit: usize, max_limit: usize) -> Self

Creates a new Pagination instance with a custom safety limit.

Arguments

• page - Zero-based page number
• limit - Items per page
• max_limit - Maximum allowed items per page

pub fn new(page: usize, limit: usize) -> Self

Creates a new Pagination instance with a default safety limit of 100.

Arguments

• page - Zero-based page number
• limit - Items per page

pub fn apply<T, E>(self, query: QueryBuilder<T, E>) -> QueryBuilder<T, E>

where T: Model + Send + Sync + Unpin + AnyImpl, E: Connection + Send,

Applies pagination settings to a QueryBuilder.

This method sets the limit and offset of the query builder based on the pagination parameters. It also enforces the max_limit check before applying the limit.

Arguments

• query - The QueryBuilder to paginate

Returns

The modified QueryBuilder

pub async fn paginate<T, E, R>( self, query: QueryBuilder<T, E>, ) -> Result<Paginated<R>, Error>

where T: Model + Send + Sync + Unpin + AnyImpl, E: Connection + Send, R: FromAnyRow + AnyImpl + Send + Unpin,

Executes the query and returns a Paginated<R> structure.

This method performs two database operations:

1. A COUNT(*) query to determine total records.
2. The actual data query with LIMIT and OFFSET applied.

Type Parameters

• T - The base Model type for the query.
• E - The connection type.
• R - The target result type (usually the same as T or a DTO).

Returns

• Ok(Paginated<R>) - The data and pagination metadata.
• Err(sqlx::Error) - Database error.

Example

let p = Pagination::new(0, 20);
let res: Paginated<User> = p.paginate(db.model::<User>()).await?;

for user in res.data {
    println!("User: {}", user.username);
}

pub async fn paginate_as<T, E, R>( self, query: QueryBuilder<T, E>, ) -> Result<Paginated<R>, Error>

where T: Model + Send + Sync + Unpin + AnyImpl, E: Connection + Send, R: FromAnyRow + AnyImpl + Send + Unpin,

Executes the query and returns a Paginated<R> mapping to a custom DTO.

This method is similar to paginate, but it uses scan_as to map the results to a type R that implements FromAnyRow but does not necessarily implement AnyImpl. This is particularly useful for complex queries involving JOINs where the result doesn’t map directly to a single Model.

Type Parameters

• T - The base Model type for the query.
• E - The connection type.
• R - The target result type (DTO/Projection).

Returns

• Ok(Paginated<R>) - The paginated results mapped to type R.
• Err(sqlx::Error) - Database error.

Trait Implementations

impl Clone for Pagination

fn clone(&self) -> Pagination

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Pagination

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Pagination

Default for axum headers

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Pagination

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Pagination

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for Pagination