Struct PaginatedQueryBuilder

pub struct PaginatedQueryBuilder<'q, T, A>
where
    T: for<'r> FromRow<'r, <Postgres as Database>::Row> + Send + Unpin,
{ /* private fields */ }

Implementations

impl<'q, T, A> PaginatedQueryBuilder<'q, T, A>

where T: for<'r> FromRow<'r, <Postgres as Database>::Row> + Send + Unpin + Serialize + Default, A: 'q + IntoArguments<'q, Postgres> + Send,

A builder for constructing and executing paginated queries.

This builder provides a fluent interface for creating paginated queries. For more examples explore examples/paginated_query_builder_advanced_examples.rs

Type Parameters

• 'q: The lifetime of the query and its arguments
• T: The model type that the query will return
• A: The type of the query arguments

Generic Constraints

• T: Must be deserializable from Postgres rows (FromRow), Send, and Unpin
• A: Must be compatible with Postgres arguments and Send

(Attention: Only Pool<Postgres> is supported at the moment)

pub fn new(query: QueryAs<'q, Postgres, T, A>) -> Self

Creates a new PaginatedQueryBuilder with default settings.

Arguments

• query - The base query to paginate

Default Settings

• Totals calculation is enabled
• Uses default query parameters
• Uses safe default query building function

Examples

use sqlx::{FromRow, Postgres};
use serde::{Serialize};
use sqlx_paginated::PaginatedQueryBuilder;

#[derive(Serialize, FromRow, Default)]
struct UserExample {
    name: String
}
let base_query = sqlx::query_as::<_, UserExample>("SELECT * FROM users");
let builder = PaginatedQueryBuilder::new(base_query);

pub fn with_query_builder( self, build_query_fn: fn(&QueryParams<'_, T>) -> (Vec<String>, PgArguments), ) -> Self

pub fn with_params(self, params: impl Into<QueryParams<'q, T>>) -> Self

pub fn disable_totals_count(self) -> Self

Disables the calculation of total record count.

When disabled, the response will not include total count or total pages. This can improve query performance for large datasets where the total count is not needed.

Returns

Returns self for method chaining

pub async fn fetch_paginated( self, pool: &Pool<Postgres>, ) -> Result<PaginatedResponse<T>, Error>

Executes the paginated query and returns the results.

Arguments

• pool - Database connection pool (Attention: Only Pool<Postgres> is supported at the moment)

Returns

Returns a Result containing a PaginatedResponse<T> with:

• Records for the requested page
• Optional Pagination information (if enabled)
• Optional total count and total pages (if enabled)

Errors

Returns sqlx::Error if the query execution fails