Struct RdbcItemWriterBuilder 

pub struct RdbcItemWriterBuilder<'a, O> { /* private fields */ }

Available on crate feature rdbc only.

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

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

Type Parameters

• O - The item type to write

Examples

PostgreSQL

use spring_batch_rs::item::rdbc::{RdbcItemWriterBuilder, DatabaseItemBinder};
use sqlx::{PgPool, query_builder::Separated, Postgres};
use serde::Serialize;

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

struct UserBinder;
impl DatabaseItemBinder<User, Postgres> for UserBinder {
    fn bind(&self, item: &User, mut query_builder: Separated<Postgres, &str>) {
        let _ = (item, query_builder); // Placeholder to avoid unused warnings
        // In real usage: query_builder.push_bind(item.id);
        // In real usage: query_builder.push_bind(&item.name);
    }
}

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

let writer = RdbcItemWriterBuilder::<User>::new()
    .postgres(&pool)
    .table("users")
    .add_column("id")
    .add_column("name")
    .postgres_binder(&binder)
    .build_postgres();

MySQL

use spring_batch_rs::item::rdbc::{RdbcItemWriterBuilder, DatabaseItemBinder};
use sqlx::{MySqlPool, query_builder::Separated, MySql};
use serde::Serialize;

#[derive(Clone, Serialize)]
struct Product {
    id: i32,
    name: String,
}

struct ProductBinder;
impl DatabaseItemBinder<Product, MySql> for ProductBinder {
    fn bind(&self, item: &Product, mut query_builder: Separated<MySql, &str>) {
        let _ = (item, query_builder); // Placeholder to avoid unused warnings
        // In real usage: query_builder.push_bind(item.id);
        // In real usage: query_builder.push_bind(&item.name);
    }
}

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

let writer = RdbcItemWriterBuilder::<Product>::new()
    .mysql(&pool)
    .table("products")
    .add_column("id")
    .add_column("name")
    .mysql_binder(&binder)
    .build_mysql();

SQLite

use spring_batch_rs::item::rdbc::{RdbcItemWriterBuilder, DatabaseItemBinder};
use sqlx::{SqlitePool, query_builder::Separated, Sqlite};
use serde::Serialize;

#[derive(Clone, Serialize)]
struct Task {
    id: i32,
    title: String,
}

struct TaskBinder;
impl DatabaseItemBinder<Task, Sqlite> for TaskBinder {
    fn bind(&self, item: &Task, mut query_builder: Separated<Sqlite, &str>) {
        let _ = (item, query_builder); // Placeholder to avoid unused warnings
        // In real usage: query_builder.push_bind(item.id);
        // In real usage: query_builder.push_bind(&item.title);
    }
}

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

let writer = RdbcItemWriterBuilder::<Task>::new()
    .sqlite(&pool)
    .table("tasks")
    .add_column("id")
    .add_column("title")
    .sqlite_binder(&binder)
    .build_sqlite();

Implementations

impl<'a, O> RdbcItemWriterBuilder<'a, O>

pub fn new() -> Self

Creates a new unified writer builder with default configuration.

pub fn postgres(self, pool: &'a 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: &'a 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: &'a 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 table(self, table: &'a str) -> Self

Sets the table name for the writer.

Arguments

• table - The database table name

Returns

The updated builder instance

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

Adds a column to the writer.

Arguments

• column - The column name

Returns

The updated builder instance

pub fn postgres_binder( self, binder: &'a dyn DatabaseItemBinder<O, Postgres>, ) -> Self

Sets the item binder for PostgreSQL.

Arguments

• binder - The PostgreSQL-specific item binder

Returns

The updated builder instance

pub fn mysql_binder(self, binder: &'a dyn DatabaseItemBinder<O, MySql>) -> Self

Sets the item binder for MySQL.

Arguments

• binder - The MySQL-specific item binder

Returns

The updated builder instance

pub fn sqlite_binder( self, binder: &'a dyn DatabaseItemBinder<O, Sqlite>, ) -> Self

Sets the item binder for SQLite.

Arguments

• binder - The SQLite-specific item binder

Returns

The updated builder instance

pub fn build_postgres(self) -> PostgresItemWriter<'a, O>

Builds a PostgreSQL writer.

Returns

A configured PostgresItemWriter instance

Panics

Panics if required PostgreSQL-specific configuration is missing

pub fn build_mysql(self) -> MySqlItemWriter<'a, O>

Builds a MySQL writer.

Returns

A configured MySqlItemWriter instance

Panics

Panics if required MySQL-specific configuration is missing

pub fn build_sqlite(self) -> SqliteItemWriter<'a, O>

Builds a SQLite writer.

Returns

A configured SqliteItemWriter instance

Panics

Panics if required SQLite-specific configuration is missing

Trait Implementations

impl<'a, O> Default for RdbcItemWriterBuilder<'a, O>

fn default() -> Self

Returns the “default value” for a type.