org.springframework.batch.item.database

## Class JdbcPagingItemReader<T>

- java.lang.Object
- - org.springframework.batch.item.ItemStreamSupport
  - - org.springframework.batch.item.support.AbstractItemStreamItemReader<T>
    - - org.springframework.batch.item.support.AbstractItemCountingItemStreamItemReader<T>
      - - org.springframework.batch.item.database.AbstractPagingItemReader<T>
        - - org.springframework.batch.item.database.JdbcPagingItemReader<T>

- All Implemented Interfaces:
    ItemReader<T>, ItemStream, ItemStreamReader<T>, org.springframework.beans.factory.InitializingBean

      public class JdbcPagingItemReader<T>
      extends AbstractPagingItemReader<T>
      implements org.springframework.beans.factory.InitializingBean

  `ItemReader` for reading database records using JDBC in a paging fashion.

  It executes the SQL built by the `PagingQueryProvider` to retrieve requested data. The query is executed using paged requests of a size specified in `AbstractPagingItemReader.setPageSize(int)`. Additional pages are requested when needed as `AbstractItemCountingItemStreamItemReader.read()` method is called, returning an object corresponding to current position. On restart it uses the last sort key value to locate the first page to read (so it doesn't matter if the successfully processed items have been removed or modified). It is important to have a unique key constraint on the sort key to guarantee that no data is lost between executions.

  The performance of the paging depends on the database specific features available to limit the number of returned rows. Setting a fairly large page size and using a commit interval that matches the page size should provide better performance.

  The implementation is thread-safe in between calls to `open(ExecutionContext)`, but remember to use `saveState=false` if used in a multi-threaded client (no restart available).

  Since:
    2.0
  Author:
    Thomas Risberg, Dave Syer, Michael Minella, Mahmoud Ben Hassine

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static int` | `VALUE_NOT_SET`

    - ### Fields inherited from class org.springframework.batch.item.database.AbstractPagingItemReader

      `logger, results`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `JdbcPagingItemReader()`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `afterPropertiesSet()` Check mandatory properties.
    `protected void` | `doJumpToPage(int itemIndex)`
    `protected void` | `doReadPage()`
    `void` | `open(ExecutionContext executionContext)` No-op.
    `void` | `setDataSource(javax.sql.DataSource dataSource)`
    `void` | `setFetchSize(int fetchSize)` Gives the JDBC driver a hint as to the number of rows that should be fetched from the database when more rows are needed for this `ResultSet` object.
    `void` | `setParameterValues(java.util.Map<java.lang.String,java.lang.Object> parameterValues)` The parameter values to be used for the query execution.
    `void` | `setQueryProvider(PagingQueryProvider queryProvider)` A `PagingQueryProvider`.
    `void` | `setRowMapper(org.springframework.jdbc.core.RowMapper<T> rowMapper)` The row mapper implementation to be used by this reader.
    `void` | `update(ExecutionContext executionContext)` Return empty `ExecutionContext`.

    - ### Methods inherited from class org.springframework.batch.item.database.AbstractPagingItemReader

      `doClose, doOpen, doRead, getPage, getPageSize, jumpToItem, setPageSize`

    - ### Methods inherited from class org.springframework.batch.item.support.AbstractItemCountingItemStreamItemReader

      `close, getCurrentItemCount, isSaveState, read, setCurrentItemCount, setMaxItemCount, setSaveState`

    - ### Methods inherited from class org.springframework.batch.item.ItemStreamSupport

      `getExecutionContextKey, setExecutionContextName, setName`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### VALUE_NOT_SET

          public static final int VALUE_NOT_SET

      See Also:
        Constant Field Values

  - ### Constructor Detail

    - #### JdbcPagingItemReader

          public JdbcPagingItemReader()

  - ### Method Detail

    - #### setDataSource

          public void setDataSource(javax.sql.DataSource dataSource)

    - #### setFetchSize

          public void setFetchSize(int fetchSize)

      Gives the JDBC driver a hint as to the number of rows that should be fetched from the database when more rows are needed for this `ResultSet` object. If the fetch size specified is zero, the JDBC driver ignores the value.
      Parameters:
        `fetchSize` - the number of rows to fetch
      See Also:
        `ResultSet.setFetchSize(int)`

    - #### setQueryProvider

          public void setQueryProvider(PagingQueryProvider queryProvider)

      A `PagingQueryProvider`. Supplies all the platform dependent query generation capabilities needed by the reader.
      Parameters:
        `queryProvider` - the `PagingQueryProvider` to use

    - #### setRowMapper

          public void setRowMapper(org.springframework.jdbc.core.RowMapper<T> rowMapper)

      The row mapper implementation to be used by this reader. The row mapper is used to convert result set rows into objects, which are then returned by the reader.
      Parameters:
        `rowMapper` - a `RowMapper` implementation

    - #### setParameterValues

          public void setParameterValues(java.util.Map<java.lang.String,java.lang.Object> parameterValues)

      The parameter values to be used for the query execution. If you use named parameters then the key should be the name used in the query clause. If you use "?" placeholders then the key should be the relative index that the parameter appears in the query string built using the select, from and where clauses specified.
      Parameters:
        `parameterValues` - the values keyed by the parameter named/index used in the query string.

    - #### afterPropertiesSet

          public void afterPropertiesSet()
                                  throws java.lang.Exception

      Check mandatory properties.
      Specified by:
        `afterPropertiesSet` in interface `org.springframework.beans.factory.InitializingBean`
      Overrides:
        `afterPropertiesSet` in class `AbstractPagingItemReader<T>`
      Throws:
        `java.lang.Exception`
      See Also:
        `InitializingBean.afterPropertiesSet()`

    - #### doReadPage

          protected void doReadPage()

      Specified by:
        `doReadPage` in class `AbstractPagingItemReader<T>`

    - #### update

          public void update(ExecutionContext executionContext)
                      throws ItemStreamException

      Description copied from class: `ItemStreamSupport`
      Return empty `ExecutionContext`.
      Specified by:
        `update` in interface `ItemStream`
      Overrides:
        `update` in class `AbstractItemCountingItemStreamItemReader<T>`
      Parameters:
        `executionContext` - to be updated
      Throws:
        `ItemStreamException`
      See Also:
        `ItemStream.update(ExecutionContext)`

    - #### open

          public void open(ExecutionContext executionContext)

      Description copied from class: `ItemStreamSupport`
      No-op.
      Specified by:
        `open` in interface `ItemStream`
      Overrides:
        `open` in class `AbstractItemCountingItemStreamItemReader<T>`
      Parameters:
        `executionContext` - current step's `ExecutionContext`. Will be the executionContext from the last run of the step on a restart.
      See Also:
        `ItemStream.open(ExecutionContext)`

    - #### doJumpToPage

          protected void doJumpToPage(int itemIndex)

      Specified by:
        `doJumpToPage` in class `AbstractPagingItemReader<T>`