org.springframework.jdbc.core

## Class SingleColumnRowMapper<T>

- java.lang.Object
- - org.springframework.jdbc.core.SingleColumnRowMapper<T>

- Type Parameters:
    `T` - the result type
  All Implemented Interfaces:
    RowMapper<T>

      public class SingleColumnRowMapper<T>
      extends Object
      implements RowMapper<T>

  `RowMapper` implementation that converts a single column into a single result value per row. Expects to operate on a `java.sql.ResultSet` that just contains a single column.

  The type of the result value for each row can be specified. The value for the single column will be extracted from the `ResultSet` and converted into the specified target type.

  Since:
    1.2
  Author:
    Juergen Hoeller, Kazuki Shimizu
  See Also:
    `JdbcTemplate.queryForList(String, Class)`, `JdbcTemplate.queryForObject(String, Class)`

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `SingleColumnRowMapper()` Create a new `SingleColumnRowMapper` for bean-style configuration.
    `SingleColumnRowMapper(Class<T> requiredType)` Create a new `SingleColumnRowMapper`.

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected Object` | `convertValueToRequiredType(Object value, Class<?> requiredType)` Convert the given column value to the specified required type.
    `protected Object` | `getColumnValue(ResultSet rs, int index)` Retrieve a JDBC object value for the specified column, using the most appropriate value type.
    `protected Object` | `getColumnValue(ResultSet rs, int index, Class<?> requiredType)` Retrieve a JDBC object value for the specified column.
    `T` | `mapRow(ResultSet rs, int rowNum)` Extract a value for the single column in the current row.
    `static <T> SingleColumnRowMapper<T>` | `newInstance(Class<T> requiredType)` Static factory method to create a new `SingleColumnRowMapper`.
    `static <T> SingleColumnRowMapper<T>` | `newInstance(Class<T> requiredType, ConversionService conversionService)` Static factory method to create a new `SingleColumnRowMapper`.
    `void` | `setConversionService(ConversionService conversionService)` Set a `ConversionService` for converting a fetched value.
    `void` | `setRequiredType(Class<T> requiredType)` Set the type that each result object is expected to match.

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

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

- - ### Constructor Detail

    - #### SingleColumnRowMapper

          public SingleColumnRowMapper()

      Create a new `SingleColumnRowMapper` for bean-style configuration.
      See Also:
        `setRequiredType(java.lang.Class<T>)`

    - #### SingleColumnRowMapper

          public SingleColumnRowMapper(Class<T> requiredType)

      Create a new `SingleColumnRowMapper`.
      Parameters:
        `requiredType` - the type that each result object is expected to match

  - ### Method Detail

    - #### setRequiredType

          public void setRequiredType(Class<T> requiredType)

      Set the type that each result object is expected to match.

      If not specified, the column value will be exposed as returned by the JDBC driver.

    - #### setConversionService

          public void setConversionService(@Nullable
                                           ConversionService conversionService)

      Set a `ConversionService` for converting a fetched value.

      Default is the `DefaultConversionService`.

      Since:
        5.0.4
      See Also:
        `DefaultConversionService.getSharedInstance()`

    - #### mapRow

          @Nullable
          public T mapRow(ResultSet rs,
                                    int rowNum)
                             throws SQLException

      Extract a value for the single column in the current row.

      Validates that there is only one column selected, then delegates to `getColumnValue()` and also `convertValueToRequiredType`, if necessary.

      Specified by:
        `mapRow` in interface `RowMapper<T>`
      Parameters:
        `rs` - the `ResultSet` to map (pre-initialized for the current row)
        `rowNum` - the number of the current row
      Returns:
        the result object for the current row (may be `null`)
      Throws:
        `SQLException` - if an SQLException is encountered while getting column values (that is, there's no need to catch SQLException)
      See Also:
        `ResultSetMetaData.getColumnCount()`, `getColumnValue(java.sql.ResultSet, int, Class)`, `convertValueToRequiredType(Object, Class)`

    - #### getColumnValue

          @Nullable
          protected Object getColumnValue(ResultSet rs,
                                                    int index,
                                                    @Nullable
                                                    Class<?> requiredType)
                                             throws SQLException

      Retrieve a JDBC object value for the specified column.

      The default implementation calls `JdbcUtils.getResultSetValue(java.sql.ResultSet, int, Class)`. If no required type has been specified, this method delegates to `getColumnValue(rs, index)`, which basically calls `ResultSet.getObject(index)` but applies some additional default conversion to appropriate value types.

      Parameters:
        `rs` - is the ResultSet holding the data
        `index` - is the column index
        `requiredType` - the type that each result object is expected to match (or `null` if none specified)
      Returns:
        the Object value
      Throws:
        `SQLException` - in case of extraction failure
      See Also:
        `JdbcUtils.getResultSetValue(java.sql.ResultSet, int, Class)`, `getColumnValue(java.sql.ResultSet, int)`

    - #### getColumnValue

          @Nullable
          protected Object getColumnValue(ResultSet rs,
                                                    int index)
                                             throws SQLException

      Retrieve a JDBC object value for the specified column, using the most appropriate value type. Called if no required type has been specified.

      The default implementation delegates to `JdbcUtils.getResultSetValue()`, which uses the `ResultSet.getObject(index)` method. Additionally, it includes a "hack" to get around Oracle returning a non-standard object for their TIMESTAMP datatype. See the `JdbcUtils#getResultSetValue()` javadoc for details.

      Parameters:
        `rs` - is the ResultSet holding the data
        `index` - is the column index
      Returns:
        the Object value
      Throws:
        `SQLException` - in case of extraction failure
      See Also:
        `JdbcUtils.getResultSetValue(java.sql.ResultSet, int)`

    - #### convertValueToRequiredType

          @Nullable
          protected Object convertValueToRequiredType(Object value,
                                                                Class<?> requiredType)

      Convert the given column value to the specified required type. Only called if the extracted column value does not match already.

      If the required type is String, the value will simply get stringified via `toString()`. In case of a Number, the value will be converted into a Number, either through number conversion or through String parsing (depending on the value type). Otherwise, the value will be converted to a required type using the `ConversionService`.

      Parameters:
        `value` - the column value as extracted from `getColumnValue()` (never `null`)
        `requiredType` - the type that each result object is expected to match (never `null`)
      Returns:
        the converted value
      See Also:
        `getColumnValue(java.sql.ResultSet, int, Class)`

    - #### newInstance

          public static <T> SingleColumnRowMapper<T> newInstance(Class<T> requiredType)

      Static factory method to create a new `SingleColumnRowMapper`.
      Parameters:
        `requiredType` - the type that each result object is expected to match
      Since:
        4.1
      See Also:
        `newInstance(Class, ConversionService)`

    - #### newInstance

          public static <T> SingleColumnRowMapper<T> newInstance(Class<T> requiredType,
                                                                 @Nullable
                                                                 ConversionService conversionService)

      Static factory method to create a new `SingleColumnRowMapper`.
      Parameters:
        `requiredType` - the type that each result object is expected to match
        `conversionService` - the `ConversionService` for converting a fetched value, or `null` for none
      Since:
        5.0.4
      See Also:
        `newInstance(Class)`, `setConversionService(org.springframework.core.convert.ConversionService)`