Add support for paging queries

Author: jeffgbutler

src/main/java/org/mybatis/dynamic/sql/util/ValueMapping.java

@@ -38,7 +38,6 @@ public <R> R accept(UpdateMappingVisitor<R> visitor) {
     }
 
     public static <T> ValueMapping<T> of(SqlColumn<T> column, Supplier<T> valueSupplier) {
-        ValueMapping<T> mapping = new ValueMapping<>(column, valueSupplier);
-        return mapping;
+        return new ValueMapping<>(column, valueSupplier);
     }
 }

src/main/java/org/mybatis/dynamic/sql/util/springbatch/SpringBatchCursorReaderSelectModel.java

@@ -0,0 +1,32 @@
+/**
+ *    Copyright 2016-2019 the original author or authors.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+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);
+    }
+}

src/main/java/org/mybatis/dynamic/sql/util/springbatch/SpringBatchPagingReaderSelectModel.java

@@ -0,0 +1,59 @@
+/**
+ *    Copyright 2016-2019 the original author or authors.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+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;
+        }
+    }
+}

src/main/java/org/mybatis/dynamic/sql/util/springbatch/SpringBatchUtility.java

@@ -18,7 +18,10 @@
 import java.util.HashMap;
 import java.util.Map;
 
+import org.mybatis.dynamic.sql.BasicColumn;
 import org.mybatis.dynamic.sql.render.RenderingStrategy;
+import org.mybatis.dynamic.sql.select.QueryExpressionDSL;
+import org.mybatis.dynamic.sql.select.SelectDSL;
 import org.mybatis.dynamic.sql.select.render.SelectStatementProvider;
 
 public class SpringBatchUtility {
@@ -34,4 +37,29 @@ public static Map<String, Object> toParameterValues(SelectStatementProvider sele
         parameterValues.put(PARAMETER_KEY, selectStatement);
         return parameterValues;
     }
+
+    /**
+     * Select builder that renders in a manner appropriate for the MyBatisPagingItemReader.
+     * 
+     * <b>Important</b> rendered SQL will contain LIMIT and OFFSET clauses in the SELECT statement. If your database
+     * (Oracle) does not support LIMIT and OFFSET, the queries will fail.
+     * 
+     * @param selectList a column list for the SELECT statement
+     * @return FromGatherer used to continue a SELECT statement
+     */
+    public static QueryExpressionDSL.FromGatherer<SpringBatchPagingReaderSelectModel> selectForPaging(
+            BasicColumn...selectList) {
+        return SelectDSL.select(SpringBatchPagingReaderSelectModel::new, selectList);
+    }
+
+    /**
+     * Select builder that renders in a manner appropriate for the MyBatisCursorItemReader.
+     * 
+     * @param selectList a column list for the SELECT statement
+     * @return FromGatherer used to continue a SELECT statement
+     */
+    public static QueryExpressionDSL.FromGatherer<SpringBatchCursorReaderSelectModel> selectForCursor(
+            BasicColumn...selectList) {
+        return SelectDSL.select(SpringBatchCursorReaderSelectModel::new, selectList);
+    }
 }

src/site/markdown/docs/springBatch.md

@@ -19,30 +19,69 @@ The solution involves these steps:
 
 MyBatis Dynamic SQL provides utilities for each of these requirements. Each utility uses a shared Map key for consistency.
 
-### Specialized Rendering
+## Spring Batch Item Readers
 
-MyBatis Dynamic SQL provides a specialized rendering strategy for queries used with the MyBatis Spring `ItemReader` implementations. Queries should be rendered as follows:
+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.
+
+
+### Rendering for Cursor
+
+Queries intended for the `MyBatisCursorItemReader` should be rendered as follows:
+
+```java
+  SelectStatementProvider selectStatement =  SpringBatchUtility.selectForCursor(person.allColumns())
+      .from(person)
+      .where(lastName, isEqualTo("flintstone"))
+      .build()
+      .render(); // renders for MyBatisCursorItemReader
+```
+
+### Rendering for Paging
+
+Queries intended for the `MyBatisPagingItemReader` should be rendered as follows:
 
 ```java
-  SelectStatementProvider selectStatement =  SelectDSL.select(person.allColumns())
+  SelectStatementProvider selectStatement =  SpringBatchUtility.selectForPaging(person.allColumns())
       .from(person)
       .where(lastName, isEqualTo("flintstone"))
       .build()
-      .render(SpringBatchUtility.SPRING_BATCH_READER_RENDERING_STRATEGY); // render for Spring Batch
+      .render(); // renders for MyBatisPagingItemReader
 ```
 
-### Creating the Parameter Map
+## Creating the Parameter Map
+
+The `SpringBatchUtility` provides a method to create the parameter values Map needed by the MyBatis Spring `ItemReader` implementations. It can be used as follows:
 
-The `SpringBatchUtility` provides a method to create the parameter values Map needed by the MyBatis Spring `ItemReader`. It can be used as follows:
+For cursor based queries...
 
 ```java
   MyBatisCursorItemReader<Person> reader = new MyBatisCursorItemReader<>();
   reader.setQueryId(PersonMapper.class.getName() + ".selectMany");
   reader.setSqlSessionFactory(sqlSessionFactory);
   reader.setParameterValues(SpringBatchUtility.toParameterValues(selectStatement)); // create parameter map
 ```
+For paging based queries...
+
+```java
+  MyBatisPagingItemReader<Person> reader = new MyBatisPagingItemReader<>();
+  reader.setQueryId(PersonMapper.class.getName() + ".selectMany");
+  reader.setSqlSessionFactory(sqlSessionFactory);
+  reader.setParameterValues(SpringBatchUtility.toParameterValues(selectStatement));
+  reader.setPageSize(7);
+```
+
 
-### Specialized @SelectProvider Adapter
+## Specialized @SelectProvider Adapter
 
 MyBatis mapper methods should be configured to use the specialized `@SelectProvider` adapter as follows:
 
@@ -58,4 +97,4 @@ MyBatis mapper methods should be configured to use the specialized `@SelectProvi
 
 ## Complete Example
 
-The unit tests for MyBatis Dynamic SQL include a complete example of using MyBatis Spring Batch support using both a reader and writer. 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)
+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)

src/test/java/examples/springbatch/BatchConfiguration.java renamed to src/test/java/examples/springbatch/CursorReaderBatchConfiguration.java

@@ -21,7 +21,6 @@
 import javax.sql.DataSource;
 
 import org.apache.ibatis.session.SqlSessionFactory;
-import org.mybatis.dynamic.sql.select.SelectDSL;
 import org.mybatis.dynamic.sql.select.render.SelectStatementProvider;
 import org.mybatis.dynamic.sql.update.render.UpdateStatementProvider;
 import org.mybatis.dynamic.sql.util.springbatch.SpringBatchUtility;
@@ -49,9 +48,9 @@
 
 @EnableBatchProcessing
 @Configuration
-@MapperScan("examples.springbatch")
 @ComponentScan("examples.springbatch")
-public class BatchConfiguration {
+@MapperScan("examples.springbatch")
+public class CursorReaderBatchConfiguration {
 
     @Autowired
     private JobBuilderFactory jobBuilderFactory;
@@ -82,11 +81,11 @@ public JobLauncherTestUtils jobLauncherTestUtils() {
 
     @Bean
     public MyBatisCursorItemReader<Person> reader(SqlSessionFactory sqlSessionFactory) {
-        SelectStatementProvider selectStatement =  SelectDSL.select(person.allColumns())
+        SelectStatementProvider selectStatement =  SpringBatchUtility.selectForCursor(person.allColumns())
                 .from(person)
                 .where(lastName, isEqualTo("flintstone"))
                 .build()
-                .render(SpringBatchUtility.SPRING_BATCH_READER_RENDERING_STRATEGY);
+                .render();
 
         MyBatisCursorItemReader<Person> reader = new MyBatisCursorItemReader<>();
         reader.setQueryId(PersonMapper.class.getName() + ".selectMany");

src/test/java/examples/springbatch/PagingReaderBatchConfiguration.java

@@ -0,0 +1,127 @@
+/**
+ *    Copyright 2016-2019 the original author or authors.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+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;
+
+@EnableBatchProcessing
+@Configuration
+@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();
+    }
+}