Struct Pagination 

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

A standard pagination structure.

Can be deserialized from query parameters (e.g., ?page=1&limit=20).

Fields

page: usize

The page number (0-indexed). Default: 0.

limit: usize

The number of items per page. Default: 10.

max_limit: usize

The maximum allowed limit for pagination to prevent large result sets. If the requested limit exceeds max_limit, it will be capped (default: 100).

Implementations

impl Pagination

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

Creates a new Pagination instance with a specified max_limit.

If limit is greater than max_limit, it defaults to 10.

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

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

Applies the pagination 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<'a, T, E, R>( self, query: QueryBuilder<'a, T, E>, ) -> Result<Paginated<R>, Error>

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

Executes the query and returns a Paginated<T> result with metadata.

This method performs two database queries:

1. A COUNT(*) query to get the total number of records matching the filters.
2. The actual SELECT query with LIMIT and OFFSET applied.

Type Parameters

• T - The Model type.
• E - The connection type (Database or Transaction).
• R - The result type (usually same as T, but can be a DTO/Projection).

Returns

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

Example

let pagination = Pagination::new(0, 10);
let result = pagination.paginate(db.model::<User>()).await?;

println!("Total users: {}", result.total);
for user in result.data {
    println!("User: {}", user.username);
}

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

where T: Model + Send + Sync + Unpin, 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

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