Struct OrmItemReaderBuilder 

pub struct OrmItemReaderBuilder<'a, I>
where
    I: EntityTrait,
{ /* private fields */ }

Available on crate feature orm only.

Builder for creating a OrmItemReader.

This builder provides a convenient way to configure and create a OrmItemReader with custom parameters like page size and database connection. It follows the builder pattern to ensure all required components are provided before creating the reader instance.

Builder Pattern Benefits

• Fluent API: Method chaining for readable configuration
• Compile-time Safety: Required fields are enforced at build time
• Flexibility: Optional parameters can be omitted
• Validation: Build method validates all required components are present

Required Components

The following components must be set before calling build():

• Connection: Database connection for executing queries
• Query: SeaORM select query to execute

Optional Components

• Page Size: When set, enables pagination for memory-efficient reading

Usage Pattern

let reader = OrmItemReaderBuilder::new()
    .connection(&db)           // Required
    .query(entity_query)       // Required
    .page_size(100)           // Optional
    .build();                 // Creates the reader

Examples

use spring_batch_rs::item::orm::OrmItemReaderBuilder;
use sea_orm::{Database, EntityTrait, FromQueryResult};
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, FromQueryResult, Deserialize, Serialize)]
struct Order {
    id: i32,
    customer_name: String,
    total_amount: f64,
    status: String,
}

// Create database connection
let db = Database::connect("postgresql://user:pass@localhost/db").await?;

// Create a query (assuming you have an orders entity)
// let query = orders::Entity::find()
//     .filter(orders::Column::Status.eq("pending"));

// Create the reader with explicit type annotations
// let reader: OrmItemReader<orders::Entity> = OrmItemReaderBuilder::new()
//     .connection(&db)
//     .query(query)
//     .page_size(100)  // Process 100 orders at a time
//     .build();

Implementations

impl<'a, I> OrmItemReaderBuilder<'a, I>

where I: EntityTrait, I::Model: FromQueryResult + Send + Sync + Clone,

pub fn page_size(self, page_size: u64) -> Self

Sets the page size for the reader.

When set, the reader will use pagination to load data in chunks of the specified size. This is useful for processing large datasets without loading everything into memory.

Memory Management

• Small page sizes (e.g., 10-100): Lower memory usage, more database round trips
• Large page sizes (e.g., 1000-10000): Higher memory usage, fewer database round trips
• No pagination (None): All data loaded at once, highest memory usage

Performance Considerations

• Choose page size based on available memory and network latency
• Consider the size of your data rows when setting page size
• Monitor memory usage and adjust as needed

Arguments

• page_size - The number of items to read per page (must be > 0 for meaningful pagination)

Returns

The updated OrmItemReaderBuilder instance for method chaining.

Examples

use spring_batch_rs::item::orm::OrmItemReaderBuilder;
use sea_orm::FromQueryResult;
use serde::{Deserialize, Serialize};

// In practice, you would use actual SeaORM entities
// #[derive(Debug, Clone, FromQueryResult)]
// struct Record {
//     id: i32,
//     data: String,
// }
//
// let builder = OrmItemReaderBuilder::<record::Entity>::new()
//     .page_size(50);  // Process 50 records at a time

pub fn query(self, query: Select<I>) -> Self

Sets the SeaORM select query for the reader.

This query will be executed to fetch data from the database. The query can include filters, joins, ordering, and other SeaORM query operations. The query will be cloned for each page fetch, so it should be relatively lightweight to clone.

Query Design Considerations

• Ordering: Include ORDER BY clauses for consistent pagination
• Filtering: Apply filters to reduce the dataset size
• Joins: Use joins to fetch related data in a single query
• Indexing: Ensure proper database indexes for query performance

Pagination Compatibility

When using pagination, the query should:

• Have a deterministic order (use ORDER BY)
• Not use LIMIT/OFFSET (handled by the paginator)
• Be compatible with SeaORM’s paginator

Arguments

• query - The SeaORM select query to execute

Returns

The updated OrmItemReaderBuilder instance for method chaining.

Examples

use spring_batch_rs::item::orm::OrmItemReaderBuilder;
use sea_orm::{EntityTrait, QueryFilter};
use serde::{Deserialize, Serialize};

// In practice, you would use actual SeaORM entities
// let query = user::Entity::find()
//     .filter(user::Column::Active.eq(true))
//     .order_by_asc(user::Column::Id);
//
// let builder = OrmItemReaderBuilder::<user::Entity>::new()
//     .query(query);

pub fn connection(self, connection: &'a DatabaseConnection) -> Self

Sets the database connection for the reader.

This connection will be used to execute the SeaORM queries. The connection must remain valid for the entire lifetime of the reader, which is enforced by the lifetime parameter ’a.

Connection Management

• The connection is borrowed, not owned by the reader
• Ensure the connection pool/manager outlives the reader
• The connection should be properly configured for your database

Database Compatibility

SeaORM supports multiple databases:

• PostgreSQL
• MySQL
• SQLite
• SQL Server (via sqlx)

Arguments

• connection - The SeaORM database connection (must outlive the reader)

Returns

The updated OrmItemReaderBuilder instance for method chaining.

Examples

use spring_batch_rs::item::orm::OrmItemReaderBuilder;
use sea_orm::{Database, EntityTrait};
use serde::{Deserialize, Serialize};

let db = Database::connect("sqlite::memory:").await?;

// In practice, you would use actual SeaORM entities
// let builder = OrmItemReaderBuilder::<product::Entity>::new()
//     .connection(&db);

pub fn build(self) -> OrmItemReader<'a, I>

Builds the ORM item reader with the configured parameters.

This method validates that all required parameters have been set and creates a new OrmItemReader instance.

Returns

A configured OrmItemReader instance

Panics

Panics if required parameters (connection and query) are missing.

Validation

The builder performs the following validation:

• Ensures a database connection has been provided
• Ensures a SeaORM query has been provided
• Page size is optional and defaults to loading all data at once

If any required parameter is missing, the method will panic with a descriptive error message.

Examples

use spring_batch_rs::item::orm::OrmItemReaderBuilder;
use sea_orm::{Database, EntityTrait};

let db = Database::connect("sqlite::memory:").await?;

// With pagination
// let reader = OrmItemReaderBuilder::new()
//     .connection(&db)
//     .query(MyEntity::find())
//     .page_size(100)
//     .build();

// Without pagination (load all at once)
// let reader = OrmItemReaderBuilder::new()
//     .connection(&db)
//     .query(MyEntity::find())
//     .build();

pub fn new() -> Self

Creates a new OrmItemReaderBuilder.

This is the entry point for the builder pattern. It creates a new builder instance with all fields set to their default values (None for optional fields).

Builder Lifecycle

1. Creation: new() creates an empty builder
2. Configuration: Use setter methods to configure the reader
3. Validation: build() validates and creates the final reader

Examples

use spring_batch_rs::item::orm::OrmItemReaderBuilder;
use sea_orm::EntityTrait;
use serde::{Deserialize, Serialize};

// In practice, you would use actual SeaORM entities
// let builder = OrmItemReaderBuilder::<record::Entity>::new()
//     .page_size(50);  // Process 50 records at a time

Trait Implementations

impl<I> Default for OrmItemReaderBuilder<'_, I>

where I: EntityTrait,

fn default() -> Self

Creates a new builder with all fields set to None/default values.

This is the starting point for the builder pattern. All required fields must be set before calling build().