Struct RdbcItemReaderBuilder 

pub struct RdbcItemReaderBuilder<'a, I> { /* private fields */ }

Available on crate feature rdbc only.

Unified builder for creating RDBC item readers for any supported database type.

This builder provides a consistent API for constructing database readers regardless of the underlying database (PostgreSQL, MySQL, or SQLite). Users specify the database type and connection pool, and the builder handles the creation of the appropriate reader implementation.

Type Parameters

• I - The item type that implements the appropriate FromRow trait for the database

Examples

PostgreSQL

use spring_batch_rs::item::rdbc::{RdbcItemReaderBuilder, DatabaseType};
use sqlx::PgPool;

let pool = PgPool::connect("postgresql://user:pass@localhost/db").await?;

let reader = RdbcItemReaderBuilder::<User>::new()
    .postgres(pool)
    .query("SELECT id, name FROM users")
    .with_page_size(100)
    .build_postgres();

MySQL

use spring_batch_rs::item::rdbc::{RdbcItemReaderBuilder, DatabaseType};
use sqlx::MySqlPool;

let pool = MySqlPool::connect("mysql://user:pass@localhost/db").await?;

let reader = RdbcItemReaderBuilder::<Product>::new()
    .mysql(pool)
    .query("SELECT id, name FROM products")
    .with_page_size(100)
    .build_mysql();

SQLite

use spring_batch_rs::item::rdbc::{RdbcItemReaderBuilder, DatabaseType};
use sqlx::SqlitePool;

let pool = SqlitePool::connect("sqlite::memory:").await?;

let reader = RdbcItemReaderBuilder::<Task>::new()
    .sqlite(pool)
    .query("SELECT id, title FROM tasks")
    .with_page_size(100)
    .build_sqlite();

Implementations

impl<'a, I> RdbcItemReaderBuilder<'a, I>

pub fn new() -> Self

Creates a new unified reader builder with default configuration.

pub fn postgres(self, pool: Pool<Postgres>) -> Self

Sets the PostgreSQL connection pool and database type.

Arguments

• pool - The PostgreSQL connection pool

Returns

The updated builder instance configured for PostgreSQL

pub fn mysql(self, pool: Pool<MySql>) -> Self

Sets the MySQL connection pool and database type.

Arguments

• pool - The MySQL connection pool

Returns

The updated builder instance configured for MySQL

pub fn sqlite(self, pool: Pool<Sqlite>) -> Self

Sets the SQLite connection pool and database type.

Arguments

• pool - The SQLite connection pool

Returns

The updated builder instance configured for SQLite

pub fn query(self, query: &'a str) -> Self

Sets the SQL query for the reader.

The query should not include LIMIT/OFFSET clauses as these are handled automatically when page_size is configured.

Arguments

• query - The SQL query to execute

Returns

The updated builder instance

pub fn select(self, builder: SelectBuilder<I>) -> Self

Configures the reader query using a SelectBuilder.

This is an ergonomic alternative to Self::query that lets you build the SQL statement through a fluent API instead of writing raw SQL. If the SelectBuilder was configured with SelectBuilder::order_by_keyset, the keyset column and key function are automatically propagated to the reader.

Calling .select() after .query() (or vice-versa) is allowed; the last call wins.

Arguments

• builder - A SelectBuilder instance ready to be compiled.

Examples

use spring_batch_rs::item::rdbc::{RdbcItemReaderBuilder, SelectBuilder};
use sqlx::SqlitePool;

let pool = SqlitePool::connect("sqlite::memory:").await?;

let reader = RdbcItemReaderBuilder::<Task>::new()
    .sqlite(pool)
    .select(
        SelectBuilder::from("tasks")
            .columns(&["id", "title"])
            .where_eq("done", false)
            .order_by_asc("id"),
    )
    .with_page_size(50)
    .build_sqlite();

pub fn with_page_size(self, page_size: i32) -> Self

Sets the page size for paginated reading.

When set, the reader will fetch data in chunks of this size to manage memory usage efficiently.

Arguments

• page_size - Number of items to read per page

Returns

The updated builder instance

pub fn with_keyset( self, column: &str, key_fn: impl Fn(&I) -> String + 'static, ) -> Self

Enables keyset (cursor) pagination instead of LIMIT/OFFSET.

Keyset pagination is O(log n) per page regardless of dataset size, making it significantly faster than LIMIT/OFFSET for large tables.

Requirements

• The query must not include WHERE, ORDER BY, or LIMIT clauses — the framework appends them automatically.
• The keyset column must be indexed and have unique, sortable values (e.g. primary key, UUID, zero-padded string ID).
• Self::with_page_size must also be set.

Arguments

• column - Column name used as the cursor (appended to WHERE and ORDER BY).
• key_fn - Closure that extracts the cursor value from an item as a String.

Examples

use spring_batch_rs::item::rdbc::RdbcItemReaderBuilder;
use sqlx::PgPool;

let pool = PgPool::connect("postgresql://user:pass@localhost/db").await?;

let reader = RdbcItemReaderBuilder::<Order>::new()
    .postgres(pool)
    .query("SELECT order_id, amount FROM orders")
    .with_page_size(1_000)
    .with_keyset("order_id", |o: &Order| o.order_id.clone())
    .build_postgres();

impl<'a, I> RdbcItemReaderBuilder<'a, I>

where for<'r> I: FromRow<'r, PgRow> + Send + Unpin + Clone,

pub fn build_postgres(self) -> PostgresRdbcItemReader<I>

Builds a PostgreSQL reader.

Returns

A configured PostgresRdbcItemReader instance

Panics

Panics if PostgreSQL pool or query are missing

impl<'a, I> RdbcItemReaderBuilder<'a, I>

where for<'r> I: FromRow<'r, MySqlRow> + Send + Unpin + Clone,

pub fn build_mysql(self) -> MySqlRdbcItemReader<I>

Builds a MySQL reader.

Returns

A configured MySqlRdbcItemReader instance

Panics

Panics if MySQL pool or query are missing

impl<'a, I> RdbcItemReaderBuilder<'a, I>

where for<'r> I: FromRow<'r, SqliteRow> + Send + Unpin + Clone,

pub fn build_sqlite(self) -> SqliteRdbcItemReader<I>

Builds a SQLite reader.

Returns

A configured SqliteRdbcItemReader instance

Panics

Panics if SQLite pool or query are missing

Trait Implementations

impl<'a, I> Default for RdbcItemReaderBuilder<'a, I>

fn default() -> Self

Returns the “default value” for a type.