Struct QueryParamsBuilder

pub struct QueryParamsBuilder<'q, T> { /* private fields */ }

Implementations

impl<'q, T: Default + Serialize> QueryParamsBuilder<'q, T>

pub fn new() -> Self

Creates a new QueryParamsBuilder with default values.

Default values include:

• Page: 1
• Page size: 10
• Sort column: “created_at”
• Sort direction: Descending

Examples

use serde::{Serialize};
use sqlx_paginated::{QueryParamsBuilder};

#[derive(Serialize, Default)]
struct UserExample {
    name: String
}
let builder = QueryParamsBuilder::<UserExample>::new();

pub fn with_pagination(self, page: i64, page_size: i64) -> Self

Creates a new QueryParamsBuilder with default values.

Default values include:

• Page: 1
• Page size: 10
• Sort column: “created_at”
• Sort direction: Descending

Examples

use serde::{Serialize};
use sqlx_paginated::{QueryParamsBuilder};

#[derive(Serialize, Default)]
struct UserExample {
    name: String
}
let builder = QueryParamsBuilder::<UserExample>::new();

pub fn with_sort( self, sort_column: impl Into<String>, sort_direction: QuerySortDirection, ) -> Self

Sets sorting parameters.

Arguments

• sort_column - Column name to sort by
• sort_direction - Direction of sort (Ascending or Descending)

Examples

use serde::{Serialize};
use sqlx_paginated::{QueryParamsBuilder, QuerySortDirection};

#[derive(Serialize, Default)]
struct UserExample {
    name: String
}

let params = QueryParamsBuilder::<UserExample>::new()
    .with_sort("updated_at", QuerySortDirection::Ascending)
    .build();

pub fn with_search( self, search: impl Into<String>, search_columns: Vec<impl Into<String>>, ) -> Self

Sets search parameters with multiple columns support.

Arguments

• search - Search term to look for
• search_columns - Vector of column names to search in

Examples

use serde::{Serialize};
use sqlx_paginated::{QueryParamsBuilder, QuerySortDirection};

#[derive(Serialize, Default)]
struct UserExample {
    name: String
}

let params = QueryParamsBuilder::<UserExample>::new()
    .with_search("john", vec!["name", "email", "username"])
    .build();

pub fn with_date_range( self, date_after: Option<DateTime<Utc>>, date_before: Option<DateTime<Utc>>, column_name: Option<impl Into<String>>, ) -> Self

Sets date range parameters for filtering by date.

Arguments

• date_after - Optional start date (inclusive)
• date_before - Optional end date (inclusive)
• column_name - Optional column name to apply date range filter (defaults to created_at)

Examples

use chrono::{DateTime, Utc};
use serde::{Serialize};
use sqlx_paginated::{QueryParamsBuilder, QuerySortDirection};

#[derive(Serialize, Default)]
struct UserExample {
    name: String,
    updated_at: DateTime<Utc>
}

let start = DateTime::parse_from_rfc3339("2024-01-01T00:00:00Z").unwrap().into();
let end = DateTime::parse_from_rfc3339("2024-12-31T23:59:59Z").unwrap().into();

let params = QueryParamsBuilder::<UserExample>::new()
    .with_date_range(Some(start), Some(end), Some("updated_at"))
    .build();

pub fn with_filter( self, key: impl Into<String>, value: Option<impl Into<String>>, ) -> Self

Adds a single filter condition.

Arguments

• key - Column name to filter on
• value - Optional value to filter by

Details

Only adds the filter if the column exists in the model struct. Logs a warning if tracing is enabled and the column is invalid.

Examples

use std::any::Any;
use serde::{Serialize};
use sqlx_paginated::{QueryParamsBuilder};

#[derive(Serialize, Default)]
struct UserExample {
    name: String,
    status: String,
    role: String
}

let params = QueryParamsBuilder::<UserExample>::new()
    .with_filter("status", Some("active"))
    .with_filter("role", Some("admin"))
    .build();

pub fn with_filters( self, filters: HashMap<impl Into<String>, Option<impl Into<String>>>, ) -> Self

Adds multiple filter conditions from a HashMap.

Arguments

• filters - HashMap of column names and their filter values

Details

Only adds filters for columns that exist in the model struct. Logs a warning if tracing is enabled and a column is invalid.

Examples

use std::collections::HashMap;
use serde::{Serialize};
use sqlx_paginated::{QueryParamsBuilder};

#[derive(Serialize, Default)]
struct UserExample {
    name: String,
    status: String,
    role: String
}

let mut filters = HashMap::new();
filters.insert("status", Some("active"));
filters.insert("role", Some("admin"));

let params = QueryParamsBuilder::<UserExample>::new()
    .with_filters(filters)
    .build();

pub fn build(self) -> QueryParams<'q, T>

Builds and returns the final QueryParams.

Returns

Returns the constructed QueryParams<T> with all the configured parameters.

Examples

use chrono::{DateTime, Utc};
use sqlx_paginated::{QueryParamsBuilder, QuerySortDirection};
use serde::{Serialize};

#[derive(Serialize, Default)]
struct UserExample {
    name: String,
    status: String,
    email: String,
    created_at: DateTime<Utc>
}

let params = QueryParamsBuilder::<UserExample>::new()
    .with_pagination(1, 20)
    .with_sort("created_at", QuerySortDirection::Descending)
    .with_search("john", vec!["name", "email"])
    .with_filter("status", Some("active"))
    .build();

Trait Implementations

impl<T: Default + Serialize> Default for QueryParamsBuilder<'_, T>

fn default() -> Self

Returns the “default value” for a type.