46  * A <code>CachedRowSet</code> object is a container for rows of data
48  * connected to its data source. Further, it is a
53  * supports getting data only from a <code>ResultSet</code> object, but
55  * access to other tabular data sources.
57  * An application can modify the data in a <code>CachedRowSet</code> object, and
58  * those modifications can then be propagated back to the source of the data.
61  * that it makes use of a connection to its data source only briefly. It connects to its
62  * data source while it is reading data to populate itself with rows and again
63  * while it is propagating changes back to its underlying data source. The rest
65  * while its data is being modified. Being disconnected makes a <code>RowSet</code>
88  * with a reader (a <code>RowSetReader</code> object) for reading data from a
89  * data source to populate itself with data. A reader can be implemented to read
90  * data from a <code>ResultSet</code> object or from a file with a tabular format.
93  * modifications to the <code>CachedRowSet</code> object's data made while it was
94  * disconnected with the data in the underlying data source.
98  * (A conflict occurs when a value in the data source has been changed after
101  * few or no conflicts and therefore sets no locks. It updates the data source
104  * Other writers can be implemented so that they always write modified data to
105  * the data source, which can be accomplished either by not checking for conflicts
106  * or, on the other end of the spectrum, by setting locks sufficient to prevent data
107  * in the data source from being changed. Still other writer implementations can be
196  *   object uses these methods internally when it is populated with data from a
213  * its data source while it is being updated, it must take an additional step
214  * to effect changes in its underlying data source. After calling the method
218  * written to the data source. The following example, in which the cursor is
221  * update the <code>RowSet</code> object's underlying data source.
231  * method <code>acceptChanges</code> to add the new row to the underlying data
253  * a <code>CachedRowSet</code> object back to the underlying data source,
255  * changes to the data source. To do this, the writer has to incur the expense
256  * of establishing a connection with that data source. The
268  * rowset to the underlying data source. The writer is implemented to make a
269  * connection to the data source and write updates to it.
278  * are any conflicts before writing data to the data source.  If there are any
279  * conflicts, it does not write anything to the data source.
283  * customization of data retrieval and updating. If a different concurrency
291  * current value). Note that if no changes have been made to the data in a
297  * changes to data in a <code>RowSet</code> object, its original values and current
327  * data also notifies registered listeners of the changes, so
333  * pass data between different components of an application. Because it is
340  * leaner than a <code>ResultSet</code> object with the same data.
341  * As a result, it can be especially suitable for sending data to a thin client
357  * with that <code>ResultSet</code> object's data.  This is demonstrated
366  * The object <code>crs</code> now contains the data from the table
375  * a disconnected set of rows that are being cached outside of a data source.
377  * and it is well suited to sending data to a thin client. However, a
379  * size by the amount of data it can store in memory at one time.
383  * possible to retrieve and store data from sources other than a relational
385  * its rowset with data from any tabular data source, including a spreadsheet
389  * can use this capability to create a rowset containing data from
390  * non-SQL data sources. Nevertheless, it is expected that most of the time,
391  * <code>CachedRowSet</code> objects will contain data that was fetched
397  * depending on what the rowset does and how it gets its data.  For example,
398  * rowsets that get their data from a <code>ResultSet</code> object need to
407  * properties for the logical name of the data source, for the user name,
417  * In order to be able to populate itself with data from a database, a rowset
422  * setter methods for setting values of each data type,
473  * this command with the following line of code, it will have the data from
485  * <code>crs</code> populates itself with the requested data from the
496  * Because a <code>CachedRowSet</code> object stores data in memory,
497  * the amount of data that it can contain at any one
499  * a <code>CachedRowSet</code> object can retrieve data from a <code>ResultSet</code>
500  * object in chunks of data, called <i>pages</i>. To take advantage of this mechanism,
504  * data will be fetched from the data source at one time. An application can also
510  * the <code>CachedRowSet</code> object must be populated with data
533  * (Remember that <i>crs</i> always has the overriding limit of how much data it can
542  * After this code has run, <i>crs</i> will contain five rows of data from the
544  * for <i>crs</i> will use <i>conHandle</i> to connect to the data source and
546  * data in <i>crs</i> in the same way that it would operate on data in any other
549  * To access the next page (chunk of data), an application calls the method
551  * and fills it with the next page of data.  For example, assume that the
553  * <i>rs</i> with 1000 rows of data.  If the page size has been set to 100, the first
556  * data in these first 100 rows, the application can again call the method
558  * with the second 100 rows from <i>rs</i>. The data from the first <code>CachedRowSet</code>
559  * object will no longer be in memory because it is replaced with the data from the
561  * the tenth <code>CachedRowSet</code> object will contain the last 100 rows of data from
562  * <i>rs</i>, which are stored in memory. At any given time, the data from only one
634     * Populates this <code>CachedRowSet</code> object with data from
646     * @param data the <code>ResultSet</code> object containing the data
655     public void populate(ResultSet data) throws SQLException;
658     * Populates this <code>CachedRowSet</code> object with data, using the
659     * given connection to produce the result set from which the data will be read.
662     * it is reading data from its data source or writing data to its data source.
665     * will use <i>conn</i> to establish a connection to the data source
666     * so that it can execute the rowset's command and read data from the
680     * data source
688     * <code>CachedRowSet</code> object to the underlying data source.
697     * back to the data source.
700     * addition to writing changes to the data source, it
705     * with those in the data source to check for conflicts. When there is a conflict,
708     * data source.
713     * sets a lock on the data source to avoid further conflicts while the
716     * and setting the value that should be persisted in the data source.
719     * data source.  If all of the values in the data source are already the
724     * writing changes to the data source when the method <code>acceptChanges</code>
733     * to true, all updates in the synchronization are committed to the data
740     * back to the data source
752     * data source backing this <code>CachedRowSet</code> object
754     * connection to the data source.
763     * can be used only when the underlying data source is a JDBC data source.
770     * addition to writing changes to the data source, it
775     * with those in the data source to check for conflicts. When there is a conflict,
778     * data source.
783     * sets a lock on the data source to avoid further conflicts while the
786     * and setting the value that should be persisted in the data source.
789     * data source.  If all of the values in the data source are already the
794     * writing changes to the data source when the method <code>acceptChanges</code>
803     * to true, all updates in the synchronization are committed to the data
811     * back to the data source
847     * are no interactions with the underlying data source, and any rowset
862     * relevant to the originating data source from which this <code>CachedRowSet</code>
935     * effect until further modification to the rowset data has occurred.
975     * object that contains all of this <code>CachedRowSet</code> object's data.
1002     * itself or on the underlying SQL data.
1075     * and the data source. For example, a rowset may need to get a handle
1124     * data source and can potentially drastically change the synchronization
1175     * the last synchronization with the underlying data source.  If there have been
1181     * currently in the data source to check for conflicts.
1214     * row have been synchronized with the data source. The current row must be tagged
1233     *         source of data for this <code>CachedRowSet</code> object or <code>null</code>
1243     * determine which table to use when comparing the values in the data source with the
1303     * Returns a new <code>RowSet</code> object backed by the same data as
1305     * <code>CachedRowSet</code> objects have a cursor over the same data.
1309     * underlying data, the method it calls notifies all registered listeners
1321     * to preserve shared data integrity: reads and writes of all
1327     *         the same data
1336     * Creates a <code>RowSet</code> object that is a deep copy of the data in
1387      * this <code>CachedRowSet</code> object's data but is independent of it.
1550      * Populates this <code>CachedRowSet</code> object with data from
1567      * @param rs the <code>ResultSet</code> object containing the data

Indexes created Tue Jul 24 14:28:13 CEST 2018