Struct spring_batch_rs::core::step::StepBuilder

source · 
pub struct StepBuilder<'a, R, W> { /* private fields */ }

Implementations§

source§

impl<'a, R, W> StepBuilder<'a, R, W>

source

pub fn new() -> StepBuilder<'a, R, W>

Examples found in repository?
examples/fake_person_generator.rs (line 19)
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

fn main() -> Result<(), BatchError> {
    let reader = PersonReaderBuilder::new().number_of_items(10).build();

    let writer = CsvItemWriterBuilder::new()
        .has_headers(false)
        .from_path(temp_dir().join("example-fake-person.csv"));

    let step: Step<Person, Person> = StepBuilder::new()
        .reader(&reader)
        .writer(&writer)
        .chunk(1000)
        .build();

    step.execute();

    Ok(())
}
More examples
Hide additional examples
examples/json_generate_fake_person.rs (line 22)
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

fn main() -> Result<(), BatchError> {
    let reader = PersonReaderBuilder::new().number_of_items(100).build();

    let path = temp_dir().join("example-fake-person.json");

    let writer = JsonItemWriterBuilder::new()
        .indent(b"  ")
        .pretty_formatter(true)
        .from_path(path);

    let step: Step<Person, Person> = StepBuilder::new()
        .reader(&reader)
        .writer(&writer)
        .chunk(10)
        .build();

    step.execute();

    Ok(())
}
examples/csv_reader_with_headers.rs (line 41)
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

fn main() -> std::io::Result<()> {
    let csv = "year,make,model,description
    1948,Porsche,356,Luxury sports car
    1967,Ford,Mustang fastback 1967,American car";

    let reader = CsvItemReaderBuilder::new()
        .has_headers(true)
        .delimiter(b',')
        .from_reader(csv.as_bytes());

    let writer = LoggerWriter::new();

    let step: Step<Record, Record> = StepBuilder::new()
        .reader(&reader)
        .writer(&writer)
        .chunk(4)
        .build();

    step.execute();

    Ok(())
}
examples/json_reader.rs (line 23)
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

fn main() -> std::io::Result<()> {
    let path = Path::new("examples/data/persons.json");

    let file = File::options()
        .append(true)
        .read(true)
        .create(false)
        .open(path)
        .expect("Unable to open file");

    let reader = JsonItemReaderBuilder::new().from_reader(file);

    let writer = LoggerWriter::new();

    let step: Step<Person, Person> = StepBuilder::new()
        .reader(&reader)
        .writer(&writer)
        .chunk(4)
        .build();

    step.execute();

    Ok(())
}
examples/transform_data_from_json_to_csv.rs (line 75)
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

fn main() -> std::io::Result<()> {
    let path = Path::new("examples/data/persons.json");

    let file = File::options()
        .append(true)
        .read(true)
        .create(false)
        .open(path)
        .expect("Unable to open file");

    let reader = JsonItemReaderBuilder::new().from_reader(file);

    let processor = UpperCaseProcessor::default();

    let writer = CsvItemWriterBuilder::new()
        .has_headers(true)
        .from_path(temp_dir().join("persons.csv"));

    let step: Step<Person, Person> = StepBuilder::new()
        .reader(&reader)
        .processor(&processor)
        .writer(&writer)
        .chunk(2)
        .build();

    step.execute();

    Ok(())
}
source

pub fn reader(self, reader: &'a impl ItemReader<R>) -> StepBuilder<'a, R, W>

Examples found in repository?
examples/fake_person_generator.rs (line 20)
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

fn main() -> Result<(), BatchError> {
    let reader = PersonReaderBuilder::new().number_of_items(10).build();

    let writer = CsvItemWriterBuilder::new()
        .has_headers(false)
        .from_path(temp_dir().join("example-fake-person.csv"));

    let step: Step<Person, Person> = StepBuilder::new()
        .reader(&reader)
        .writer(&writer)
        .chunk(1000)
        .build();

    step.execute();

    Ok(())
}
More examples
Hide additional examples
examples/json_generate_fake_person.rs (line 23)
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

fn main() -> Result<(), BatchError> {
    let reader = PersonReaderBuilder::new().number_of_items(100).build();

    let path = temp_dir().join("example-fake-person.json");

    let writer = JsonItemWriterBuilder::new()
        .indent(b"  ")
        .pretty_formatter(true)
        .from_path(path);

    let step: Step<Person, Person> = StepBuilder::new()
        .reader(&reader)
        .writer(&writer)
        .chunk(10)
        .build();

    step.execute();

    Ok(())
}
examples/csv_reader_with_headers.rs (line 42)
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

fn main() -> std::io::Result<()> {
    let csv = "year,make,model,description
    1948,Porsche,356,Luxury sports car
    1967,Ford,Mustang fastback 1967,American car";

    let reader = CsvItemReaderBuilder::new()
        .has_headers(true)
        .delimiter(b',')
        .from_reader(csv.as_bytes());

    let writer = LoggerWriter::new();

    let step: Step<Record, Record> = StepBuilder::new()
        .reader(&reader)
        .writer(&writer)
        .chunk(4)
        .build();

    step.execute();

    Ok(())
}
examples/json_reader.rs (line 24)
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

fn main() -> std::io::Result<()> {
    let path = Path::new("examples/data/persons.json");

    let file = File::options()
        .append(true)
        .read(true)
        .create(false)
        .open(path)
        .expect("Unable to open file");

    let reader = JsonItemReaderBuilder::new().from_reader(file);

    let writer = LoggerWriter::new();

    let step: Step<Person, Person> = StepBuilder::new()
        .reader(&reader)
        .writer(&writer)
        .chunk(4)
        .build();

    step.execute();

    Ok(())
}
examples/transform_data_from_json_to_csv.rs (line 76)
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

fn main() -> std::io::Result<()> {
    let path = Path::new("examples/data/persons.json");

    let file = File::options()
        .append(true)
        .read(true)
        .create(false)
        .open(path)
        .expect("Unable to open file");

    let reader = JsonItemReaderBuilder::new().from_reader(file);

    let processor = UpperCaseProcessor::default();

    let writer = CsvItemWriterBuilder::new()
        .has_headers(true)
        .from_path(temp_dir().join("persons.csv"));

    let step: Step<Person, Person> = StepBuilder::new()
        .reader(&reader)
        .processor(&processor)
        .writer(&writer)
        .chunk(2)
        .build();

    step.execute();

    Ok(())
}
source

pub fn processor( self, processor: &'a impl ItemProcessor<R, W> ) -> StepBuilder<'a, R, W>

Examples found in repository?
examples/transform_data_from_json_to_csv.rs (line 77)
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

fn main() -> std::io::Result<()> {
    let path = Path::new("examples/data/persons.json");

    let file = File::options()
        .append(true)
        .read(true)
        .create(false)
        .open(path)
        .expect("Unable to open file");

    let reader = JsonItemReaderBuilder::new().from_reader(file);

    let processor = UpperCaseProcessor::default();

    let writer = CsvItemWriterBuilder::new()
        .has_headers(true)
        .from_path(temp_dir().join("persons.csv"));

    let step: Step<Person, Person> = StepBuilder::new()
        .reader(&reader)
        .processor(&processor)
        .writer(&writer)
        .chunk(2)
        .build();

    step.execute();

    Ok(())
}
source

pub fn writer(self, writer: &'a impl ItemWriter<W>) -> StepBuilder<'a, R, W>

Examples found in repository?
examples/fake_person_generator.rs (line 21)
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

fn main() -> Result<(), BatchError> {
    let reader = PersonReaderBuilder::new().number_of_items(10).build();

    let writer = CsvItemWriterBuilder::new()
        .has_headers(false)
        .from_path(temp_dir().join("example-fake-person.csv"));

    let step: Step<Person, Person> = StepBuilder::new()
        .reader(&reader)
        .writer(&writer)
        .chunk(1000)
        .build();

    step.execute();

    Ok(())
}
More examples
Hide additional examples
examples/json_generate_fake_person.rs (line 24)
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

fn main() -> Result<(), BatchError> {
    let reader = PersonReaderBuilder::new().number_of_items(100).build();

    let path = temp_dir().join("example-fake-person.json");

    let writer = JsonItemWriterBuilder::new()
        .indent(b"  ")
        .pretty_formatter(true)
        .from_path(path);

    let step: Step<Person, Person> = StepBuilder::new()
        .reader(&reader)
        .writer(&writer)
        .chunk(10)
        .build();

    step.execute();

    Ok(())
}
examples/csv_reader_with_headers.rs (line 43)
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

fn main() -> std::io::Result<()> {
    let csv = "year,make,model,description
    1948,Porsche,356,Luxury sports car
    1967,Ford,Mustang fastback 1967,American car";

    let reader = CsvItemReaderBuilder::new()
        .has_headers(true)
        .delimiter(b',')
        .from_reader(csv.as_bytes());

    let writer = LoggerWriter::new();

    let step: Step<Record, Record> = StepBuilder::new()
        .reader(&reader)
        .writer(&writer)
        .chunk(4)
        .build();

    step.execute();

    Ok(())
}
examples/json_reader.rs (line 25)
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

fn main() -> std::io::Result<()> {
    let path = Path::new("examples/data/persons.json");

    let file = File::options()
        .append(true)
        .read(true)
        .create(false)
        .open(path)
        .expect("Unable to open file");

    let reader = JsonItemReaderBuilder::new().from_reader(file);

    let writer = LoggerWriter::new();

    let step: Step<Person, Person> = StepBuilder::new()
        .reader(&reader)
        .writer(&writer)
        .chunk(4)
        .build();

    step.execute();

    Ok(())
}
examples/transform_data_from_json_to_csv.rs (line 78)
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

fn main() -> std::io::Result<()> {
    let path = Path::new("examples/data/persons.json");

    let file = File::options()
        .append(true)
        .read(true)
        .create(false)
        .open(path)
        .expect("Unable to open file");

    let reader = JsonItemReaderBuilder::new().from_reader(file);

    let processor = UpperCaseProcessor::default();

    let writer = CsvItemWriterBuilder::new()
        .has_headers(true)
        .from_path(temp_dir().join("persons.csv"));

    let step: Step<Person, Person> = StepBuilder::new()
        .reader(&reader)
        .processor(&processor)
        .writer(&writer)
        .chunk(2)
        .build();

    step.execute();

    Ok(())
}
source

pub fn chunk(self, chunk_size: usize) -> StepBuilder<'a, R, W>

Examples found in repository?
examples/fake_person_generator.rs (line 22)
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

fn main() -> Result<(), BatchError> {
    let reader = PersonReaderBuilder::new().number_of_items(10).build();

    let writer = CsvItemWriterBuilder::new()
        .has_headers(false)
        .from_path(temp_dir().join("example-fake-person.csv"));

    let step: Step<Person, Person> = StepBuilder::new()
        .reader(&reader)
        .writer(&writer)
        .chunk(1000)
        .build();

    step.execute();

    Ok(())
}
More examples
Hide additional examples
examples/json_generate_fake_person.rs (line 25)
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

fn main() -> Result<(), BatchError> {
    let reader = PersonReaderBuilder::new().number_of_items(100).build();

    let path = temp_dir().join("example-fake-person.json");

    let writer = JsonItemWriterBuilder::new()
        .indent(b"  ")
        .pretty_formatter(true)
        .from_path(path);

    let step: Step<Person, Person> = StepBuilder::new()
        .reader(&reader)
        .writer(&writer)
        .chunk(10)
        .build();

    step.execute();

    Ok(())
}
examples/csv_reader_with_headers.rs (line 44)
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

fn main() -> std::io::Result<()> {
    let csv = "year,make,model,description
    1948,Porsche,356,Luxury sports car
    1967,Ford,Mustang fastback 1967,American car";

    let reader = CsvItemReaderBuilder::new()
        .has_headers(true)
        .delimiter(b',')
        .from_reader(csv.as_bytes());

    let writer = LoggerWriter::new();

    let step: Step<Record, Record> = StepBuilder::new()
        .reader(&reader)
        .writer(&writer)
        .chunk(4)
        .build();

    step.execute();

    Ok(())
}
examples/json_reader.rs (line 26)
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

fn main() -> std::io::Result<()> {
    let path = Path::new("examples/data/persons.json");

    let file = File::options()
        .append(true)
        .read(true)
        .create(false)
        .open(path)
        .expect("Unable to open file");

    let reader = JsonItemReaderBuilder::new().from_reader(file);

    let writer = LoggerWriter::new();

    let step: Step<Person, Person> = StepBuilder::new()
        .reader(&reader)
        .writer(&writer)
        .chunk(4)
        .build();

    step.execute();

    Ok(())
}
examples/transform_data_from_json_to_csv.rs (line 79)
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

fn main() -> std::io::Result<()> {
    let path = Path::new("examples/data/persons.json");

    let file = File::options()
        .append(true)
        .read(true)
        .create(false)
        .open(path)
        .expect("Unable to open file");

    let reader = JsonItemReaderBuilder::new().from_reader(file);

    let processor = UpperCaseProcessor::default();

    let writer = CsvItemWriterBuilder::new()
        .has_headers(true)
        .from_path(temp_dir().join("persons.csv"));

    let step: Step<Person, Person> = StepBuilder::new()
        .reader(&reader)
        .processor(&processor)
        .writer(&writer)
        .chunk(2)
        .build();

    step.execute();

    Ok(())
}
source

pub fn build(self) -> Step<'a, R, W>
where DefaultProcessor: ItemProcessor<R, W>,

Examples found in repository?
examples/fake_person_generator.rs (line 23)
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

fn main() -> Result<(), BatchError> {
    let reader = PersonReaderBuilder::new().number_of_items(10).build();

    let writer = CsvItemWriterBuilder::new()
        .has_headers(false)
        .from_path(temp_dir().join("example-fake-person.csv"));

    let step: Step<Person, Person> = StepBuilder::new()
        .reader(&reader)
        .writer(&writer)
        .chunk(1000)
        .build();

    step.execute();

    Ok(())
}
More examples
Hide additional examples
examples/json_generate_fake_person.rs (line 26)
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

fn main() -> Result<(), BatchError> {
    let reader = PersonReaderBuilder::new().number_of_items(100).build();

    let path = temp_dir().join("example-fake-person.json");

    let writer = JsonItemWriterBuilder::new()
        .indent(b"  ")
        .pretty_formatter(true)
        .from_path(path);

    let step: Step<Person, Person> = StepBuilder::new()
        .reader(&reader)
        .writer(&writer)
        .chunk(10)
        .build();

    step.execute();

    Ok(())
}
examples/csv_reader_with_headers.rs (line 45)
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

fn main() -> std::io::Result<()> {
    let csv = "year,make,model,description
    1948,Porsche,356,Luxury sports car
    1967,Ford,Mustang fastback 1967,American car";

    let reader = CsvItemReaderBuilder::new()
        .has_headers(true)
        .delimiter(b',')
        .from_reader(csv.as_bytes());

    let writer = LoggerWriter::new();

    let step: Step<Record, Record> = StepBuilder::new()
        .reader(&reader)
        .writer(&writer)
        .chunk(4)
        .build();

    step.execute();

    Ok(())
}
examples/json_reader.rs (line 27)
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

fn main() -> std::io::Result<()> {
    let path = Path::new("examples/data/persons.json");

    let file = File::options()
        .append(true)
        .read(true)
        .create(false)
        .open(path)
        .expect("Unable to open file");

    let reader = JsonItemReaderBuilder::new().from_reader(file);

    let writer = LoggerWriter::new();

    let step: Step<Person, Person> = StepBuilder::new()
        .reader(&reader)
        .writer(&writer)
        .chunk(4)
        .build();

    step.execute();

    Ok(())
}
examples/transform_data_from_json_to_csv.rs (line 80)
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

fn main() -> std::io::Result<()> {
    let path = Path::new("examples/data/persons.json");

    let file = File::options()
        .append(true)
        .read(true)
        .create(false)
        .open(path)
        .expect("Unable to open file");

    let reader = JsonItemReaderBuilder::new().from_reader(file);

    let processor = UpperCaseProcessor::default();

    let writer = CsvItemWriterBuilder::new()
        .has_headers(true)
        .from_path(temp_dir().join("persons.csv"));

    let step: Step<Person, Person> = StepBuilder::new()
        .reader(&reader)
        .processor(&processor)
        .writer(&writer)
        .chunk(2)
        .build();

    step.execute();

    Ok(())
}

Trait Implementations§

source§

impl<'a, R: Default, W: Default> Default for StepBuilder<'a, R, W>

source§

fn default() -> StepBuilder<'a, R, W>

Returns the “default value” for a type. Read more

Auto Trait Implementations§

§

impl<'a, R, W> !RefUnwindSafe for StepBuilder<'a, R, W>

§

impl<'a, R, W> !Send for StepBuilder<'a, R, W>

§

impl<'a, R, W> !Sync for StepBuilder<'a, R, W>

§

impl<'a, R, W> Unpin for StepBuilder<'a, R, W>

§

impl<'a, R, W> !UnwindSafe for StepBuilder<'a, R, W>

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> Fake for T

source§

fn fake<U>(&self) -> U
where Self: FakeBase<U>,

source§

fn fake_with_rng<U, R>(&self, rng: &mut R) -> U
where R: Rng + ?Sized, Self: FakeBase<U>,

source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V