spring-batch-rs 0.3.4

A toolkit for building enterprise-grade batch applications
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

use sqlx::{Database, query_builder::Separated};

/// Common utilities for database item writers.
mod writer_common;

/// Common utilities for database item readers.
mod reader_common;

/// Database type enumeration.
mod database_type;

/// Unified reader builder for all database types.
mod unified_reader_builder;

/// Unified writer builder for all database types.
mod unified_writer_builder;

/// PostgreSQL-specific reader implementation.
pub mod postgres_reader;

/// MySQL-specific reader implementation.
pub mod mysql_reader;

/// SQLite-specific reader implementation.
pub mod sqlite_reader;

/// PostgreSQL-specific writer implementation.
pub mod postgres_writer;

/// MySQL-specific writer implementation.
pub mod mysql_writer;

/// SQLite-specific writer implementation.
pub mod sqlite_writer;

/// Trait for binding item data to database query parameters.
///
/// This trait is generic over the database type, allowing it to work with
/// PostgreSQL, MySQL, SQLite, and other databases supported by SQLx.
/// This provides a unified interface for database-specific item writers.
///
/// # Type Parameters
///
/// * `O` - The item type to bind
/// * `DB` - The SQLx database type (e.g., `Postgres`, `MySql`, `Sqlite`)
///
/// # Examples
///
/// ## PostgreSQL Implementation
/// ```no_run
/// use spring_batch_rs::item::rdbc::DatabaseItemBinder;
/// use sqlx::{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);
///     }
/// }
/// ```
///
/// ## MySQL Implementation
/// ```no_run
/// use spring_batch_rs::item::rdbc::DatabaseItemBinder;
/// use sqlx::{query_builder::Separated, MySql};
/// use serde::Serialize;
///
/// #[derive(Clone, Serialize)]
/// struct Product {
///     id: i32,
///     name: String,
///     price: f64,
/// }
///
/// 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);
///         // In real usage: query_builder.push_bind(item.price);
///     }
/// }
/// ```
///
/// ## SQLite Implementation
/// ```no_run
/// use spring_batch_rs::item::rdbc::DatabaseItemBinder;
/// use sqlx::{query_builder::Separated, Sqlite};
/// use serde::Serialize;
///
/// #[derive(Clone, Serialize)]
/// struct Task {
///     id: i32,
///     title: String,
///     completed: bool,
/// }
///
/// 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);
///         // In real usage: query_builder.push_bind(item.completed);
///     }
/// }
/// ```
pub trait DatabaseItemBinder<O, DB: Database> {
    /// Binds the properties of an item to a separated query builder.
    ///
    /// # Arguments
    ///
    /// * `item` - The item whose properties should be bound.
    /// * `query_builder` - The separated query builder to bind parameters to.
    fn bind(&self, item: &O, query_builder: Separated<DB, &str>);
}

// Re-export database-specific reader and writer types (for direct usage)
pub use mysql_reader::MySqlRdbcItemReader;
pub use mysql_writer::MySqlItemWriter;
pub use postgres_reader::PostgresRdbcItemReader;
pub use postgres_writer::PostgresItemWriter;
pub use sqlite_reader::SqliteRdbcItemReader;
pub use sqlite_writer::SqliteItemWriter;

// Re-export unified builder types (recommended API)
pub use database_type::DatabaseType;
pub use unified_reader_builder::RdbcItemReaderBuilder;
pub use unified_writer_builder::RdbcItemWriterBuilder;