return new ValueMapping<>(column, valueSupplier);

package org.mybatis.dynamic.sql.util.springbatch;

import org.mybatis.dynamic.sql.select.SelectModel;

import org.mybatis.dynamic.sql.select.render.SelectStatementProvider;

public class SpringBatchCursorReaderSelectModel {

private SelectModel selectModel;

public SpringBatchCursorReaderSelectModel(SelectModel selectModel) {

this.selectModel = selectModel;

}

public SelectStatementProvider render() {

return selectModel.render(SpringBatchUtility.SPRING_BATCH_READER_RENDERING_STRATEGY);

}

}

package org.mybatis.dynamic.sql.util.springbatch;

import java.util.HashMap;

import java.util.Map;

import org.mybatis.dynamic.sql.select.SelectModel;

import org.mybatis.dynamic.sql.select.render.SelectStatementProvider;

public class SpringBatchPagingReaderSelectModel {

private SelectModel selectModel;

public SpringBatchPagingReaderSelectModel(SelectModel selectModel) {

this.selectModel = selectModel;

}

public SelectStatementProvider render() {

SelectStatementProvider selectStatement =

selectModel.render(SpringBatchUtility.SPRING_BATCH_READER_RENDERING_STRATEGY);

return new LimitAndOffsetDecorator(selectStatement);

}

public class LimitAndOffsetDecorator implements SelectStatementProvider {

private Map<String, Object> parameters = new HashMap<>();

private String selectStatement;

public LimitAndOffsetDecorator(SelectStatementProvider delegate) {

parameters.putAll(delegate.getParameters());

selectStatement = delegate.getSelectStatement()

+ " LIMIT #{_pagesize} OFFSET #{_skiprows}"; //$NON-NLS-1$

}

@Override

public Map<String, Object> getParameters() {

return parameters;

}

@Override

public String getSelectStatement() {

return selectStatement;

}

}

}

import org.mybatis.dynamic.sql.BasicColumn;

import org.mybatis.dynamic.sql.select.QueryExpressionDSL;

import org.mybatis.dynamic.sql.select.SelectDSL;

/**

public static QueryExpressionDSL.FromGatherer<SpringBatchPagingReaderSelectModel> selectForPaging(

BasicColumn...selectList) {

return SelectDSL.select(SpringBatchPagingReaderSelectModel::new, selectList);

}

/**

public static QueryExpressionDSL.FromGatherer<SpringBatchCursorReaderSelectModel> selectForCursor(

BasicColumn...selectList) {

return SelectDSL.select(SpringBatchCursorReaderSelectModel::new, selectList);

}

MyBatis Spring support supplies two implementations of the `ItemReader` interface:

1. `org.mybatis.spring.batch.MyBatisCursorItemReader` - for queries that can be efficiently processed through a single select statement and a cursor

1. `org.mybatis.spring.batch.MyBatisPagingItemReader` - for queries that should be processed as a series of paged selects. Note that MyBatis does not provide any native support for paged queries - it is up to the user to write SQL for paging. The `MyBatisPagingItemWriter` simply makes properties available that specify which page should be read currently.

MyBatis Dynamic SQL supplies specialized select statements that will render properly for the different implementations of `ItemReader`:

1. `SpringBatchUtility.selectForCursor(...)` will create a select statement that is appropriate for the `MyBatisCursorItemReader` - a single select statement that will be read with a cursor

1. `SpringBatchUtility.selectForPaging(...)` will create a select statement that is appropriate for the `MyBatisPagingItemReader` - a select statement that will be called multiple times - one for each page as configured on the batch job.

**Very Important:** The paging implementation will only work for databases that support limit and offset in select statements. Fortunately, most databases do support this - with the notable exception of Oracle.

Queries intended for the `MyBatisCursorItemReader` should be rendered as follows:

SelectStatementProvider selectStatement = SpringBatchUtility.selectForCursor(person.allColumns())

.from(person)

.where(lastName, isEqualTo("flintstone"))

.build()

.render(); // renders for MyBatisCursorItemReader

Queries intended for the `MyBatisPagingItemReader` should be rendered as follows:

SelectStatementProvider selectStatement = SpringBatchUtility.selectForPaging(person.allColumns())

.render(); // renders for MyBatisPagingItemReader

The `SpringBatchUtility` provides a method to create the parameter values Map needed by the MyBatis Spring `ItemReader` implementations. It can be used as follows:

For paging based queries...

MyBatisPagingItemReader<Person> reader = new MyBatisPagingItemReader<>();

reader.setQueryId(PersonMapper.class.getName() + ".selectMany");

reader.setSqlSessionFactory(sqlSessionFactory);

reader.setParameterValues(SpringBatchUtility.toParameterValues(selectStatement));

reader.setPageSize(7);

The unit tests for MyBatis Dynamic SQL include a complete examples of using MyBatis Spring Batch support using the MyBatis supplied reader as well as both types of MyBatis supplied writers. You can see the full example here: [https://github.com/mybatis/mybatis-dynamic-sql/tree/master/src/test/java/examples/springbatch](https://github.com/mybatis/mybatis-dynamic-sql/tree/master/src/test/java/examples/springbatch)

@MapperScan("examples.springbatch")

public class CursorReaderBatchConfiguration {

SelectStatementProvider selectStatement = SpringBatchUtility.selectForCursor(person.allColumns())

.render();

package examples.springbatch;

import static examples.springbatch.PersonDynamicSqlSupport.*;

import static org.mybatis.dynamic.sql.SqlBuilder.*;

import javax.sql.DataSource;

import org.apache.ibatis.session.SqlSessionFactory;

import org.mybatis.dynamic.sql.select.render.SelectStatementProvider;

import org.mybatis.dynamic.sql.update.render.UpdateStatementProvider;

import org.mybatis.dynamic.sql.util.springbatch.SpringBatchUtility;

import org.mybatis.spring.SqlSessionFactoryBean;

import org.mybatis.spring.annotation.MapperScan;

import org.mybatis.spring.batch.MyBatisBatchItemWriter;

import org.mybatis.spring.batch.MyBatisPagingItemReader;

import org.springframework.batch.core.Job;

import org.springframework.batch.core.Step;

import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;

import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;

import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;

import org.springframework.batch.core.launch.support.RunIdIncrementer;

import org.springframework.batch.item.ItemProcessor;

import org.springframework.batch.item.ItemReader;

import org.springframework.batch.item.ItemWriter;

import org.springframework.batch.test.JobLauncherTestUtils;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.ComponentScan;

import org.springframework.context.annotation.Configuration;

import org.springframework.core.convert.converter.Converter;

import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseBuilder;

import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType;

@ComponentScan("examples.springbatch")

@MapperScan("examples.springbatch")

public class PagingReaderBatchConfiguration {

@Autowired

private JobBuilderFactory jobBuilderFactory;

@Autowired

private StepBuilderFactory stepBuilderFactory;

@Bean

public DataSource dataSource() {

return new EmbeddedDatabaseBuilder()

.setType(EmbeddedDatabaseType.HSQL)

.addScript("classpath:/examples/springbatch/schema.sql")

.addScript("classpath:/examples/springbatch/data.sql")

.build();

}

@Bean

public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource dataSource) {

SqlSessionFactoryBean bean = new SqlSessionFactoryBean();

bean.setDataSource(dataSource);

return bean;

}

@Bean

public JobLauncherTestUtils jobLauncherTestUtils() {

return new JobLauncherTestUtils();

}

@Bean

public MyBatisPagingItemReader<Person> reader(SqlSessionFactory sqlSessionFactory) {

SelectStatementProvider selectStatement = SpringBatchUtility.selectForPaging(person.allColumns())

.from(person)

.where(forPagingTest, isEqualTo(true))

.orderBy(id)

.build()

.render();

MyBatisPagingItemReader<Person> reader = new MyBatisPagingItemReader<>();

reader.setQueryId(PersonMapper.class.getName() + ".selectMany");

reader.setSqlSessionFactory(sqlSessionFactory);

reader.setParameterValues(SpringBatchUtility.toParameterValues(selectStatement));

reader.setPageSize(7);

return reader;

}

@Bean

public MyBatisBatchItemWriter<Person> writer(SqlSessionFactory sqlSessionFactory,

Converter<Person, UpdateStatementProvider> convertor) {

MyBatisBatchItemWriter<Person> writer = new MyBatisBatchItemWriter<>();

writer.setSqlSessionFactory(sqlSessionFactory);

writer.setItemToParameterConverter(convertor);

writer.setStatementId(PersonMapper.class.getName() + ".update");

return writer;

}

@Bean

public Step step1(ItemReader<Person> reader, ItemProcessor<Person, Person> processor, ItemWriter<Person> writer) {

return stepBuilderFactory.get("step1")

.<Person, Person>chunk(7)

.reader(reader)

.processor(processor)

.writer(writer)

.build();

}

@Bean

public Job upperCaseLastName(Step step1) {

return jobBuilderFactory.get("upperCaseLastName")

.incrementer(new RunIdIncrementer())

.flow(step1)

.end()

.build();

}

}