Struct PostgresRdbcItemReader 

pub struct PostgresRdbcItemReader<'a, I>
where
    for<'r> I: FromRow<'r, PgRow> + Send + Unpin + Clone,
{ /* private fields */ }

Available on crate feature rdbc only.

PostgreSQL RDBC Item Reader for batch processing

This reader provides efficient reading of database records with optional pagination to manage memory usage. It implements the ItemReader trait for integration with Spring Batch processing patterns and is specifically optimized for PostgreSQL databases.

Design

• Uses SQLx’s PostgreSQL-specific driver for optimal performance
• Supports automatic deserialization using the FromRow trait
• Implements pagination with LIMIT/OFFSET for memory-efficient processing
• Maintains an internal buffer to minimize database round trips
• Uses interior mutability (Cell/RefCell) for state management in single-threaded contexts

Memory Management

• Uses internal buffering with configurable page sizes
• Automatically handles pagination with LIMIT/OFFSET SQL clauses
• Clears buffer between pages to minimize memory footprint
• Pre-allocates buffer capacity when page size is known

Thread Safety

• Uses Cell and RefCell for interior mutability in single-threaded contexts
• Not thread-safe - should be used within a single thread
• Designed for use in Spring Batch’s single-threaded step execution model

How Pagination Works

When page_size is provided:

• Data is loaded in batches of page_size items using SQL LIMIT/OFFSET
• When all items in a batch have been read, a new batch is automatically loaded
• The offset tracks both the SQL OFFSET clause and position within the buffer
• Buffer is cleared and refilled for each new page to manage memory

When page_size is not provided:

• All data is loaded in one query without LIMIT/OFFSET
• The offset only tracks the current position in the buffer
• Suitable for smaller datasets that fit comfortably in memory

Type Parameters

• I - The item type that must implement:
  • FromRow<PgRow> for automatic deserialization from PostgreSQL rows
  • Send + Unpin for async compatibility
  • Clone for efficient item retrieval from the buffer

Construction

This reader can only be created through RdbcItemReaderBuilder. Direct construction is not available to ensure proper configuration.

Implementations

impl<'a, I> PostgresRdbcItemReader<'a, I>

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

pub fn new(pool: Pool<Postgres>, query: &'a str, page_size: Option<i32>) -> Self

Creates a new PostgresRdbcItemReader with the specified parameters

This constructor is only accessible within the crate to enforce the use of RdbcItemReaderBuilder for creating reader instances.

Arguments

• pool - PostgreSQL connection pool for database operations
• query - SQL query to execute (without LIMIT/OFFSET)
• page_size - Optional page size for pagination. None means read all at once.

Returns

A new PostgresRdbcItemReader instance ready for use.

Trait Implementations

impl<I> ItemReader<I> for PostgresRdbcItemReader<'_, I>

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

Implementation of ItemReader trait for PostgresRdbcItemReader.

This implementation provides a way to read items from a PostgreSQL database with support for pagination. It uses an internal buffer to store the results of database queries and keeps track of the current offset to determine when a new page of data needs to be fetched.

The implementation handles both paginated and non-paginated reading modes transparently, making it suitable for various batch processing scenarios.

fn read(&self) -> ItemReaderResult<I>

Reads the next item from the PostgreSQL database

This method implements the ItemReader trait and provides the core reading logic with automatic pagination management:

1. Index Calculation: Determines the current position within the current page
2. Page Loading: Loads a new page if we’re at the beginning of a page
3. Item Retrieval: Returns the item at the current position from the buffer
4. Offset Management: Advances the offset for the next read operation

Pagination Logic

For paginated reading (when page_size is Some):

• index = offset % page_size gives position within current page
• When index == 0, we’re at the start of a new page and need to load data
• Buffer contains only the current page’s items

For non-paginated reading (when page_size is None):

• index = offset gives absolute position in the full result set
• Data is loaded only once when index == 0 (first read)
• Buffer contains all items from the query

Returns

• Ok(Some(item)) if an item was successfully read
• Ok(None) if there are no more items to read (end of result set)
• Err(BatchError::ItemReader) if a database error occurred

Examples

use spring_batch_rs::core::item::ItemReader;

let reader = PostgresRdbcItemReader::<User>::new(
    pool,
    "SELECT id, name FROM users ORDER BY id",
    Some(100)
);

// Read items one by one
let mut count = 0;
while let Some(user) = reader.read()? {
    println!("User: {} - {}", user.id, user.name);
    count += 1;
}
println!("Processed {} users", count);