javax.faces.model

## Class ResultSetDataModel

- java.lang.Object
- - javax.faces.model.DataModel<Map<String,Object>>
  - - javax.faces.model.ResultSetDataModel

- All Implemented Interfaces:
    Iterable<Map<String,Object>>

      public class ResultSetDataModel
      extends DataModel<Map<String,Object>>

  ResultSetDataModel is a convenience implementation of `DataModel` that wraps a `ResultSet` of Java objects. Note that the specified `ResultSet` MUST be scrollable. In addition, if input components (that will be updating model values) reference this object in value binding expressions, the specified `ResultSet` MUST be updatable.

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `ResultSetDataModel()` Construct a new `ResultSetDataModel` with no specified wrapped data.
    `ResultSetDataModel(ResultSet resultSet)` Construct a new `ResultSetDataModel` wrapping the specified `ResultSet`.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `int` | `getRowCount()` Return -1, since `ResultSet` does not provide a standard way to determine the number of available rows without scrolling through the entire `ResultSet`, and this can be very expensive if the number of rows is large.
    `Map<String,Object>` | `getRowData()` If row data is available, return a `Map` representing the values of the columns for the row specified by `rowIndex`, keyed by the corresponding column names.
    `int` | `getRowIndex()` Return the zero-relative index of the currently selected row.
    `Object` | `getWrappedData()` Return the object representing the data wrapped by this `DataModel`, if any.
    `boolean` | `isRowAvailable()` Return `true` if there is `wrappedData` available, and the result of calling `absolute()` on the underlying `ResultSet`, passing the current value of `rowIndex` plus one (to account for the fact that `ResultSet` uses one-relative indexing), returns `true`.
    `void` | `setRowIndex(int rowIndex)` Set the zero-relative index of the currently selected row, or -1 to indicate that we are not positioned on a row.
    `void` | `setWrappedData(Object data)` Set the object representing the data collection wrapped by this `DataModel`.

    - ### Methods inherited from class javax.faces.model.DataModel

      `addDataModelListener, getDataModelListeners, iterator, removeDataModelListener`

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

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

- - ### Constructor Detail

    - #### ResultSetDataModel

          public ResultSetDataModel()

      Construct a new `ResultSetDataModel` with no specified wrapped data.

    - #### ResultSetDataModel

          public ResultSetDataModel(ResultSet resultSet)

      Construct a new `ResultSetDataModel` wrapping the specified `ResultSet`.

      Parameters:
        `resultSet` - `ResultSet` to be wrapped (if any)

  - ### Method Detail

    - #### isRowAvailable

          public boolean isRowAvailable()

      Return `true` if there is `wrappedData` available, and the result of calling `absolute()` on the underlying `ResultSet`, passing the current value of `rowIndex` plus one (to account for the fact that `ResultSet` uses one-relative indexing), returns `true`. Otherwise, return `false`.

      Specified by:
        `isRowAvailable` in class `DataModel<Map<String,Object>>`
      Throws:
        `FacesException` - if an error occurs getting the row availability

    - #### getRowCount

          public int getRowCount()

      Return -1, since `ResultSet` does not provide a standard way to determine the number of available rows without scrolling through the entire `ResultSet`, and this can be very expensive if the number of rows is large.

      Specified by:
        `getRowCount` in class `DataModel<Map<String,Object>>`
      Throws:
        `FacesException` - if an error occurs getting the row count

    - #### getRowData

          public Map<String,Object> getRowData()

      If row data is available, return a `Map` representing the values of the columns for the row specified by `rowIndex`, keyed by the corresponding column names. If no wrapped data is available, return `null`.

      If a non-`null` `Map` is returned, its behavior must correspond to the contract for a mutable `Map` as described in the JavaDocs for `AbstractMap`, with the following exceptions and specialized behavior:

      - The `Map`, and any supporting objects it returns, must perform all column name comparisons in a case-insensitive manner. This case-insensitivity must be implemented using a case-insensitive `Comparator`, such as `String.CASE_INSENSITIVE_ORDER`.
      - The following methods must throw `UnsupportedOperationException`: `clear()`, `remove()`.
      - The `entrySet()` method must return a `Set` that has the following behavior:
        - Throw `UnsupportedOperationException` for any attempt to add or remove entries from the `Set`, either directly or indirectly through an `Iterator` returned by the `Set`.
        - Updates to the `value` of an entry in this `set` must write through to the corresponding column value in the underlying `ResultSet`.
      - The `keySet()` method must return a `Set` that throws `UnsupportedOperationException` on any attempt to add or remove keys, either directly or through an `Iterator` returned by the `Set`.
      - The `put()` method must throw `IllegalArgumentException` if a key value for which `containsKey()` returns `false` is specified. However, if a key already present in the `Map` is specified, the specified value must write through to the corresponding column value in the underlying `ResultSet`.
      - The `values()` method must return a `Collection` that throws `UnsupportedOperationException` on any attempt to add or remove values, either directly or through an `Iterator` returned by the `Collection`.
      Specified by:
        `getRowData` in class `DataModel<Map<String,Object>>`
      Throws:
        `FacesException` - if an error occurs getting the row data
        `IllegalArgumentException` - if now row data is available at the currently specified row index

    - #### getRowIndex

          public int getRowIndex()

      Description copied from class: `DataModel`

      Return the zero-relative index of the currently selected row. If we are not currently positioned on a row, or no `wrappedData` is available, return -1.

      Specified by:
        `getRowIndex` in class `DataModel<Map<String,Object>>`
      Throws:
        `FacesException` - if an error occurs getting the row index

    - #### setRowIndex

          public void setRowIndex(int rowIndex)

      Description copied from class: `DataModel`

      Set the zero-relative index of the currently selected row, or -1 to indicate that we are not positioned on a row. It is possible to set the row index at a value for which the underlying data collection does not contain any row data. Therefore, callers may use the `isRowAvailable()` method to detect whether row data will be available for use by the `getRowData()` method.

      If there is no `wrappedData` available when this method is called, the specified `rowIndex` is stored (and may be retrieved by a subsequent call to `getRowData()`), but no event is sent. Otherwise, if the currently selected row index is changed by this call, a `DataModelEvent` will be sent to the `rowSelected()` method of all registered `DataModelListener`s.

      Specified by:
        `setRowIndex` in class `DataModel<Map<String,Object>>`
      Parameters:
        `rowIndex` - The new zero-relative index (must be non-negative)
      Throws:
        `FacesException` - if an error occurs setting the row index
        `IllegalArgumentException` - if `rowIndex` is less than -1

    - #### getWrappedData

          public Object getWrappedData()

      Description copied from class: `DataModel`

      Return the object representing the data wrapped by this `DataModel`, if any.

      Specified by:
        `getWrappedData` in class `DataModel<Map<String,Object>>`

    - #### setWrappedData

          public void setWrappedData(Object data)

      Description copied from class: `DataModel`

      Set the object representing the data collection wrapped by this `DataModel`. If the specified `data` is `null`, detach this `DataModel` from any previously wrapped data collection instead.

      If `data` is non-`null`, the currently selected row index must be set to zero, and a `DataModelEvent` must be sent to the `rowSelected()` method of all registered `DataModelListener`s indicating that this row is now selected.

      Specified by:
        `setWrappedData` in class `DataModel<Map<String,Object>>`
      Parameters:
        `data` - Data collection to be wrapped, or `null` to detach from any previous data collection
      Throws:
        `ClassCastException` - if `data` is not of the appropriate type for this `DataModel` implementation

Copyright © 1996-2013, Oracle and/or its affiliates. All Rights Reserved. Use is subject to license terms.