Struct PaginatedQueryBuilder 

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

Implementations

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

where DB: Database, T: for<'r> FromRow<'r, <DB as Database>::Row> + Send + Unpin + Serialize + Default, A: 'q + IntoArguments<'q, DB> + Send, DB::Arguments<'q>: IntoArguments<'q, DB>, for<'c> &'c Pool<DB>: Executor<'c, Database = DB>, usize: ColumnIndex<<DB as Database>::Row>, i64: Type<DB> + for<'r> Decode<'r, DB> + Send + Unpin,

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

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

where F: for<'p> Fn(&'p QueryParams<'_, T>) -> (Vec<String>, DB::Arguments<'p>) + Send + Sync + 'static,

Creates a new PaginatedQueryBuilder with default settings.

Arguments

• query - The base query to paginate
• build_query_fn - Function to build query conditions and arguments

Default Settings

• Totals calculation is enabled
• Uses default query parameters

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::<Postgres, UserExample>("SELECT * FROM users");
let builder = PaginatedQueryBuilder::new(base_query, |params| {
    sqlx_paginated::QueryBuilder::<UserExample, Postgres>::new()
        .with_search(params)
        .with_filters(params)
        .with_date_range(params)
        .build()
});

pub fn with_query_builder<F>(self, build_query_fn: F) -> Self

where F: for<'p> Fn(&'p QueryParams<'_, T>) -> (Vec<String>, DB::Arguments<'p>) + Send + Sync + 'static,

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

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

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

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

Creates a new PaginatedQueryBuilder for PostgreSQL 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::<Postgres, UserExample>("SELECT * FROM users");
let builder = PaginatedQueryBuilder::<UserExample, Postgres, _>::new_with_defaults(base_query);

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

Executes the paginated query and returns the results.

Arguments

• pool - PostgreSQL database connection pool

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

Example

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

#[derive(Serialize, FromRow, Default)]
struct User {
    id: i32,
    name: String,
}

let params = QueryParamsBuilder::<User>::new()
    .with_pagination(1, 10)
    .build();

let result = PaginatedQueryBuilder::<User, Postgres, _>::new_with_defaults(
    sqlx::query_as::<Postgres, User>("SELECT * FROM users")
)
.with_params(params)
.fetch_paginated(&pool)
.await?;