1 /*

     2  * Copyright (c) 2003, 2016, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 package javax.sql.rowset;

    27 

    28 import java.sql.*;

    29 import javax.sql.*;

    30 import java.util.*;

    31 import java.io.*;

    32 import java.math.*;

    33 import java.io.Serializable;

    34 

    35 import javax.sql.rowset.serial.*;

    36 

    37 /**

    38  * An abstract class providing a <code>RowSet</code> object with its basic functionality.

    39  * The basic functions include having properties and sending event notifications,

    40  * which all JavaBeans™ components must implement.

    41  *

    42  * <h3>1.0 Overview</h3>

    43  * The <code>BaseRowSet</code> class provides the core functionality

    44  * for all <code>RowSet</code> implementations,

    45  * and all standard implementations <b>may</b> use this class in combination with

    46  * one or more <code>RowSet</code> interfaces in order to provide a standard

    47  * vendor-specific implementation.  To clarify, all implementations must implement

    48  * at least one of the <code>RowSet</code> interfaces (<code>JdbcRowSet</code>,

    49  * <code>CachedRowSet</code>, <code>JoinRowSet</code>, <code>FilteredRowSet</code>,

    50  * or <code>WebRowSet</code>). This means that any implementation that extends

    51  * the <code>BaseRowSet</code> class must also implement one of the <code>RowSet</code>

    52  * interfaces.

    53  * <p>

    54  * The <code>BaseRowSet</code> class provides the following:

    55  *

    56  * <UL>

    57  * <LI><b>Properties</b>

    58  *     <ul>

    59  *     <li>Fields for storing current properties

    60  *     <li>Methods for getting and setting properties

    61  *     </ul>

    62  *

    63  * <LI><b>Event notification</b>

    64  *

    65  * <LI><b>A complete set of setter methods</b> for setting the parameters in a

    66  *      <code>RowSet</code> object's command

    67  *

    68  * <LI> <b>Streams</b>

    69  *  <ul>

    70  *  <li>Fields for storing stream instances

    71  *  <li>Constants for indicating the type of a stream

    72  *  </ul>

    73  * </UL>

    74  *

    75  * <h3>2.0 Setting Properties</h3>

    76  * All rowsets maintain a set of properties, which will usually be set using

    77  * a tool.  The number and kinds of properties a rowset has will vary,

    78  * depending on what the <code>RowSet</code> implementation does and how it gets

    79  * its data.  For example,

    80  * rowsets that get their data from a <code>ResultSet</code> object need to

    81  * set the properties that are required for making a database connection.

    82  * If a <code>RowSet</code> object uses the <code>DriverManager</code> facility to make a

    83  * connection, it needs to set a property for the JDBC URL that identifies the

    84  * appropriate driver, and it needs to set the properties that give the

    85  * user name and password.

    86  * If, on the other hand, the rowset uses a <code>DataSource</code> object

    87  * to make the connection, which is the preferred method, it does not need to

    88  * set the property for the JDBC URL.  Instead, it needs to set the property

    89  * for the logical name of the data source along with the properties for

    90  * the user name and password.

    91  * <P>

    92  * NOTE:  In order to use a <code>DataSource</code> object for making a

    93  * connection, the <code>DataSource</code> object must have been registered

    94  * with a naming service that uses the Java Naming and Directory

    95  * Interface™ (JNDI) API.  This registration

    96  * is usually done by a person acting in the capacity of a system administrator.

    97  *

    98  * <h3>3.0 Setting the Command and Its Parameters</h3>

    99  * When a rowset gets its data from a relational database, it executes a command (a query)

   100  * that produces a <code>ResultSet</code> object.  This query is the command that is set

   101  * for the <code>RowSet</code> object's command property.  The rowset populates itself with data by reading the

   102  * data from the <code>ResultSet</code> object into itself. If the query

   103  * contains placeholders for values to be set, the <code>BaseRowSet</code> setter methods

   104  * are used to set these values. All setter methods allow these values to be set

   105  * to <code>null</code> if required.

   106  * <P>

   107  * The following code fragment illustrates how the

   108  * <code>CachedRowSet</code>&trade;

   109  * object <code>crs</code> might have its command property set.  Note that if a

   110  * tool is used to set properties, this is the code that the tool would use.

   111  * <PRE>{@code

   112  *    crs.setCommand("SELECT FIRST_NAME, LAST_NAME, ADDRESS FROM CUSTOMERS" +

   113  *                   "WHERE CREDIT_LIMIT > ? AND REGION = ?");

   114  * }</PRE>

   115  * <P>

   116  * In this example, the values for <code>CREDIT_LIMIT</code> and

   117  * <code>REGION</code> are placeholder parameters, which are indicated with a

   118  * question mark (?).  The first question mark is placeholder parameter number

   119  * <code>1</code>, the second question mark is placeholder parameter number

   120  * <code>2</code>, and so on.  Any placeholder parameters must be set with

   121  * values before the query can be executed. To set these

   122  * placeholder parameters, the <code>BaseRowSet</code> class provides a set of setter

   123  * methods, similar to those provided by the <code>PreparedStatement</code>

   124  * interface, for setting values of each data type.  A <code>RowSet</code> object stores the

   125  * parameter values internally, and its <code>execute</code> method uses them internally

   126  * to set values for the placeholder parameters

   127  * before it sends the command to the DBMS to be executed.

   128  * <P>

   129  * The following code fragment demonstrates

   130  * setting the two parameters in the query from the previous example.

   131  * <PRE>{@code

   132  *    crs.setInt(1, 5000);

   133  *    crs.setString(2, "West");

   134  * }</PRE>

   135  * If the <code>execute</code> method is called at this point, the query

   136  * sent to the DBMS will be:

   137  * <PRE>{@code

   138  *    "SELECT FIRST_NAME, LAST_NAME, ADDRESS FROM CUSTOMERS" +

   139  *                   "WHERE CREDIT_LIMIT > 5000 AND REGION = 'West'"

   140  * }</PRE>

   141  * NOTE: Setting <code>Array</code>, <code>Clob</code>, <code>Blob</code> and

   142  * <code>Ref</code> objects as a command parameter, stores these values as

   143  * <code>SerialArray</code>, <code>SerialClob</code>, <code>SerialBlob</code>

   144  * and <code>SerialRef</code> objects respectively.

   145  *

   146  * <h3>4.0 Handling of Parameters Behind the Scenes</h3>

   147  *

   148  * NOTE: The <code>BaseRowSet</code> class provides two kinds of setter methods,

   149  * those that set properties and those that set placeholder parameters. The setter

   150  * methods discussed in this section are those that set placeholder parameters.

   151  * <P>

   152  * The placeholder parameters set with the <code>BaseRowSet</code> setter methods

   153  * are stored as objects in an internal <code>Hashtable</code> object.

   154  * Primitives are stored as their <code>Object</code> type. For example, <code>byte</code>

   155  * is stored as <code>Byte</code> object, and <code>int</code> is stored as

   156  * an <code>Integer</code> object.

   157  * When the method <code>execute</code> is called, the values in the

   158  * <code>Hashtable</code> object are substituted for the appropriate placeholder

   159  * parameters in the command.

   160  * <P>

   161  * A call to the method <code>getParams</code> returns the values stored in the

   162  * <code>Hashtable</code> object as an array of <code>Object</code> instances.

   163  * An element in this array may be a simple <code>Object</code> instance or an

   164  * array (which is a type of <code>Object</code>). The particular setter method used

   165  * determines whether an element in this array is an <code>Object</code> or an array.

   166  * <P>

   167  * The majority of methods for setting placeholder parameters take two parameters,

   168  *  with the first parameter

   169  * indicating which placeholder parameter is to be set, and the second parameter

   170  * giving the value to be set.  Methods such as <code>setInt</code>,

   171  * <code>setString</code>, <code>setBoolean</code>, and <code>setLong</code> fall into

   172  * this category.  After these methods have been called, a call to the method

   173  * <code>getParams</code> will return an array with the values that have been set. Each

   174  * element in the array is an <code>Object</code> instance representing the

   175  * values that have been set. The order of these values in the array is determined by the

   176  * <code>int</code> (the first parameter) passed to the setter method. The values in the

   177  * array are the values (the second parameter) passed to the setter method.

   178  * In other words, the first element in the array is the value

   179  * to be set for the first placeholder parameter in the <code>RowSet</code> object's

   180  * command. The second element is the value to

   181  * be set for the second placeholder parameter, and so on.

   182  * <P>

   183  * Several setter methods send the driver and DBMS information beyond the value to be set.

   184  * When the method <code>getParams</code> is called after one of these setter methods has

   185  * been used, the elements in the array will themselves be arrays to accommodate the

   186  * additional information. In this category, the method <code>setNull</code> is a special case

   187  * because one version takes only

   188  * two parameters (<code>setNull(int parameterIndex, int SqlType)</code>). Nevertheless,

   189  * it requires

   190  * an array to contain the information that will be passed to the driver and DBMS.  The first

   191  * element in this array is the value to be set, which is <code>null</code>, and the

   192  * second element is the <code>int</code> supplied for <i>sqlType</i>, which

   193  * indicates the type of SQL value that is being set to <code>null</code>. This information

   194  * is needed by some DBMSs and is therefore required in order to ensure that applications

   195  * are portable.

   196  * The other version is intended to be used when the value to be set to <code>null</code>

   197  * is a user-defined type. It takes three parameters

   198  * (<code>setNull(int parameterIndex, int sqlType, String typeName)</code>) and also

   199  * requires an array to contain the information to be passed to the driver and DBMS.

   200  * The first two elements in this array are the same as for the first version of

   201  * <code>setNull</code>.  The third element, <i>typeName</i>, gives the SQL name of

   202  * the user-defined type. As is true with the other setter methods, the number of the

   203  * placeholder parameter to be set is indicated by an element's position in the array

   204  * returned by <code>getParams</code>.  So, for example, if the parameter

   205  * supplied to <code>setNull</code> is <code>2</code>, the second element in the array

   206  * returned by <code>getParams</code> will be an array of two or three elements.

   207  * <P>

   208  * Some methods, such as <code>setObject</code> and <code>setDate</code> have versions

   209  * that take more than two parameters, with the extra parameters giving information

   210  * to the driver or the DBMS. For example, the methods <code>setDate</code>,

   211  * <code>setTime</code>, and <code>setTimestamp</code> can take a <code>Calendar</code>

   212  * object as their third parameter.  If the DBMS does not store time zone information,

   213  * the driver uses the <code>Calendar</code> object to construct the <code>Date</code>,

   214  * <code>Time</code>, or <code>Timestamp</code> object being set. As is true with other

   215  * methods that provide additional information, the element in the array returned

   216  * by <code>getParams</code> is an array instead of a simple <code>Object</code> instance.

   217  * <P>

   218  * The methods <code>setAsciiStream</code>, <code>setBinaryStream</code>,

   219  * <code>setCharacterStream</code>, and <code>setUnicodeStream</code> (which is

   220  * deprecated, so applications should use <code>getCharacterStream</code> instead)

   221  * take three parameters, so for them, the element in the array returned by

   222  * <code>getParams</code> is also an array.  What is different about these setter

   223  * methods is that in addition to the information provided by parameters, the array contains

   224  * one of the <code>BaseRowSet</code> constants indicating the type of stream being set.

   225 * <p>

   226 * NOTE: The method <code>getParams</code> is called internally by

   227 * <code>RowSet</code> implementations extending this class; it is not normally called by an

   228 * application programmer directly.

   229 *

   230 * <h3>5.0 Event Notification</h3>

   231 * The <code>BaseRowSet</code> class provides the event notification

   232 * mechanism for rowsets.  It contains the field

   233 * <code>listeners</code>, methods for adding and removing listeners, and

   234 * methods for notifying listeners of changes.

   235 * <P>

   236 * A listener is an object that has implemented the <code>RowSetListener</code> interface.

   237 * If it has been added to a <code>RowSet</code> object's list of listeners, it will be notified

   238 *  when an event occurs on that <code>RowSet</code> object.  Each listener's

   239 * implementation of the <code>RowSetListener</code> methods defines what that object

   240 * will do when it is notified that an event has occurred.

   241 * <P>

   242 * There are three possible events for a <code>RowSet</code> object:

   243 * <OL>

   244 * <LI>the cursor moves

   245 * <LI>an individual row is changed (updated, deleted, or inserted)

   246 * <LI>the contents of the entire <code>RowSet</code> object  are changed

   247 * </OL>

   248 * <P>

   249 * The <code>BaseRowSet</code> method used for the notification indicates the

   250 * type of event that has occurred.  For example, the method

   251 * <code>notifyRowChanged</code> indicates that a row has been updated,

   252 * deleted, or inserted.  Each of the notification methods creates a

   253 * <code>RowSetEvent</code> object, which is supplied to the listener in order to

   254 * identify the <code>RowSet</code> object on which the event occurred.

   255 * What the listener does with this information, which may be nothing, depends on how it was

   256 * implemented.

   257 *

   258 * <h3>6.0 Default Behavior</h3>

   259 * A default <code>BaseRowSet</code> object is initialized with many starting values.

   260 *

   261 * The following is true of a default <code>RowSet</code> instance that extends

   262 * the <code>BaseRowSet</code> class:

   263 * <UL>

   264 *   <LI>Has a scrollable cursor and does not show changes

   265 *       made by others.

   266 *   <LI>Is updatable.

   267 *   <LI>Does not show rows that have been deleted.

   268 *   <LI>Has no time limit for how long a driver may take to

   269 *       execute the <code>RowSet</code> object's command.

   270 *   <LI>Has no limit for the number of rows it may contain.

   271 *   <LI>Has no limit for the number of bytes a column may contain. NOTE: This

   272 *   limit applies only to columns that hold values of the

   273 *   following types:  <code>BINARY</code>, <code>VARBINARY</code>,

   274 *   <code>LONGVARBINARY</code>, <code>CHAR</code>, <code>VARCHAR</code>,

   275 *   and <code>LONGVARCHAR</code>.

   276 *   <LI>Will not see uncommitted data (make "dirty" reads).

   277 *   <LI>Has escape processing turned on.

   278 *   <LI>Has its connection's type map set to <code>null</code>.

   279 *   <LI>Has an empty <code>Vector</code> object for storing the values set

   280 *       for the placeholder parameters in the <code>RowSet</code> object's command.

   281 * </UL>

   282 * <p>

   283 * If other values are desired, an application must set the property values

   284 * explicitly. For example, the following line of code sets the maximum number

   285 * of rows for the <code>CachedRowSet</code> object <i>crs</i> to 500.

   286 * <PRE>

   287 *    crs.setMaxRows(500);

   288 * </PRE>

   289 * Methods implemented in extensions of this <code>BaseRowSet</code> class <b>must</b> throw an

   290 * <code>SQLException</code> object for any violation of the defined assertions.  Also, if the

   291 * extending class overrides and reimplements any <code>BaseRowSet</code> method and encounters

   292 * connectivity or underlying data source issues, that method <b>may</b> in addition throw an

   293 * <code>SQLException</code> object for that reason.

   294 *

   295 * @since 1.5

   296 */

   297 

   298 public abstract class BaseRowSet implements Serializable, Cloneable {

   299 

   300     /**

   301      * A constant indicating to a <code>RowSetReaderImpl</code> object

   302      * that a given parameter is a Unicode stream. This

   303      * <code>RowSetReaderImpl</code> object is provided as an extension of the

   304      * <code>SyncProvider</code> abstract class defined in the

   305      * <code>SyncFactory</code> static factory SPI mechanism.

   306      */

   307     public static final int UNICODE_STREAM_PARAM = 0;

   308 

   309     /**

   310      * A constant indicating to a <code>RowSetReaderImpl</code> object

   311      * that a given parameter is a binary stream. A

   312      * <code>RowSetReaderImpl</code> object is provided as an extension of the

   313      * <code>SyncProvider</code> abstract class defined in the

   314      * <code>SyncFactory</code> static factory SPI mechanism.

   315      */

   316     public static final int BINARY_STREAM_PARAM = 1;

   317 

   318     /**

   319      * A constant indicating to a <code>RowSetReaderImpl</code> object

   320      * that a given parameter is an ASCII stream. A

   321      * <code>RowSetReaderImpl</code> object is provided as an extension of the

   322      * <code>SyncProvider</code> abstract class defined in the

   323      * <code>SyncFactory</code> static factory SPI mechanism.

   324      */

   325     public static final int ASCII_STREAM_PARAM = 2;

   326 

   327     /**

   328      * The <code>InputStream</code> object that will be

   329      * returned by the method <code>getBinaryStream</code>, which is

   330      * specified in the <code>ResultSet</code> interface.

   331      * @serial

   332      */

   333     protected java.io.InputStream binaryStream;

   334 

   335     /**

   336      * The <code>InputStream</code> object that will be

   337      * returned by the method <code>getUnicodeStream</code>,

   338      * which is specified in the <code>ResultSet</code> interface.

   339      * @serial

   340      */

   341     protected java.io.InputStream unicodeStream;

   342 

   343     /**

   344      * The <code>InputStream</code> object that will be

   345      * returned by the method <code>getAsciiStream</code>,

   346      * which is specified in the <code>ResultSet</code> interface.

   347      * @serial

   348      */

   349     protected java.io.InputStream asciiStream;

   350 

   351     /**

   352      * The <code>Reader</code> object that will be

   353      * returned by the method <code>getCharacterStream</code>,

   354      * which is specified in the <code>ResultSet</code> interface.

   355      * @serial

   356      */

   357     protected java.io.Reader charStream;

   358 

   359     /**

   360      * The query that will be sent to the DBMS for execution when the

   361      * method <code>execute</code> is called.

   362      * @serial

   363      */

   364     private String command;

   365 

   366     /**

   367      * The JDBC URL the reader, writer, or both supply to the method

   368      * <code>DriverManager.getConnection</code> when the

   369      * <code>DriverManager</code> is used to get a connection.

   370      * <P>

   371      * The JDBC URL identifies the driver to be used to make the connection.

   372      * This URL can be found in the documentation supplied by the driver

   373      * vendor.

   374      * @serial

   375      */

   376     private String URL;

   377 

   378     /**

   379      * The logical name of the data source that the reader/writer should use

   380      * in order to retrieve a <code>DataSource</code> object from a Java

   381      * Directory and Naming Interface (JNDI) naming service.

   382      * @serial

   383      */

   384     private String dataSource;

   385 

   386     /**

   387      * The user name the reader, writer, or both supply to the method

   388      * <code>DriverManager.getConnection</code> when the

   389      * <code>DriverManager</code> is used to get a connection.

   390      * @serial

   391      */

   392     private transient String username;

   393 

   394     /**

   395      * The password the reader, writer, or both supply to the method

   396      * <code>DriverManager.getConnection</code> when the

   397      * <code>DriverManager</code> is used to get a connection.

   398      * @serial

   399      */

   400     private transient String password;

   401 

   402     /**

   403      * A constant indicating the type of this JDBC <code>RowSet</code>

   404      * object. It must be one of the following <code>ResultSet</code>

   405      * constants:  <code>TYPE_FORWARD_ONLY</code>,

   406      * <code>TYPE_SCROLL_INSENSITIVE</code>, or

   407      * <code>TYPE_SCROLL_SENSITIVE</code>.

   408      * @serial

   409      */

   410     private int rowSetType = ResultSet.TYPE_SCROLL_INSENSITIVE;

   411 

   412     /**

   413      * A <code>boolean</code> indicating whether deleted rows are visible in this

   414      * JDBC <code>RowSet</code> object .

   415      * @serial

   416      */

   417     private boolean showDeleted = false; // default is false

   418 

   419     /**

   420      * The maximum number of seconds the driver

   421      * will wait for a command to execute.  This limit applies while

   422      * this JDBC <code>RowSet</code> object is connected to its data

   423      * source, that is, while it is populating itself with

   424      * data and while it is writing data back to the data source.

   425      * @serial

   426      */

   427     private int queryTimeout = 0; // default is no timeout

   428 

   429     /**

   430      * The maximum number of rows the reader should read.

   431      * @serial

   432      */

   433     private int maxRows = 0; // default is no limit

   434 

   435     /**

   436      * The maximum field size the reader should read.

   437      * @serial

   438      */

   439     private int maxFieldSize = 0; // default is no limit

   440 

   441     /**

   442      * A constant indicating the concurrency of this JDBC <code>RowSet</code>

   443      * object. It must be one of the following <code>ResultSet</code>

   444      * constants: <code>CONCUR_READ_ONLY</code> or

   445      * <code>CONCUR_UPDATABLE</code>.

   446      * @serial

   447      */

   448     private int concurrency = ResultSet.CONCUR_UPDATABLE;

   449 

   450     /**

   451      * A <code>boolean</code> indicating whether this JDBC <code>RowSet</code>

   452      * object is read-only.  <code>true</code> indicates that it is read-only;

   453      * <code>false</code> that it is writable.

   454      * @serial

   455      */

   456     private boolean readOnly;

   457 

   458     /**

   459      * A <code>boolean</code> indicating whether the reader for this

   460      * JDBC <code>RowSet</code> object should perform escape processing.

   461      * <code>true</code> means that escape processing is turned on;

   462      * <code>false</code> that it is not. The default is <code>true</code>.

   463      * @serial

   464      */

   465     private boolean escapeProcessing = true;

   466 

   467     /**

   468      * A constant indicating the isolation level of the connection

   469      * for this JDBC <code>RowSet</code> object . It must be one of

   470      * the following <code>Connection</code> constants:

   471      * <code>TRANSACTION_NONE</code>,

   472      * <code>TRANSACTION_READ_UNCOMMITTED</code>,

   473      * <code>TRANSACTION_READ_COMMITTED</code>,

   474      * <code>TRANSACTION_REPEATABLE_READ</code> or

   475      * <code>TRANSACTION_SERIALIZABLE</code>.

   476      * @serial

   477      */

   478     private int isolation;

   479 

   480     /**

   481      * A constant used as a hint to the driver that indicates the direction in

   482      * which data from this JDBC <code>RowSet</code> object  is going

   483      * to be fetched. The following <code>ResultSet</code> constants are

   484      * possible values:

   485      * <code>FETCH_FORWARD</code>,

   486      * <code>FETCH_REVERSE</code>,

   487      * <code>FETCH_UNKNOWN</code>.

   488      * <P>

   489      * Unused at this time.

   490      * @serial

   491      */

   492     private int fetchDir = ResultSet.FETCH_FORWARD; // default fetch direction

   493 

   494     /**

   495      * A hint to the driver that indicates the expected number of rows

   496      * in this JDBC <code>RowSet</code> object .

   497      * <P>

   498      * Unused at this time.

   499      * @serial

   500      */

   501     private int fetchSize = 0; // default fetchSize

   502 

   503     /**

   504      * The <code>java.util.Map</code> object that contains entries mapping

   505      * SQL type names to classes in the Java programming language for the

   506      * custom mapping of user-defined types.

   507      * @serial

   508      */

   509     private Map<String, Class<?>> map;

   510 

   511     /**

   512      * A <code>Vector</code> object that holds the list of listeners

   513      * that have registered with this <code>RowSet</code> object.

   514      * @serial

   515      */

   516     private Vector<RowSetListener> listeners;

   517 

   518     /**

   519      * A <code>Vector</code> object that holds the parameters set

   520      * for this <code>RowSet</code> object's current command.

   521      * @serial

   522      */

   523     private Hashtable<Integer, Object> params; // could be transient?

   524 

   525     /**

   526      * Constructs a new <code>BaseRowSet</code> object initialized with

   527      * a default <code>Vector</code> object for its <code>listeners</code>

   528      * field. The other default values with which it is initialized are listed

   529      * in Section 6.0 of the class comment for this class.

   530      */

   531     public BaseRowSet() {

   532         // allocate the listeners collection

   533         listeners = new Vector<RowSetListener>();

   534     }

   535 

   536     /**

   537      * Performs the necessary internal configurations and initializations

   538      * to allow any JDBC <code>RowSet</code> implementation to start using

   539      * the standard facilities provided by a <code>BaseRowSet</code>

   540      * instance. This method <b>should</b> be called after the <code>RowSet</code> object

   541      * has been instantiated to correctly initialize all parameters. This method

   542      * <b>should</b> never be called by an application, but is called from with

   543      * a <code>RowSet</code> implementation extending this class.

   544      */

   545     protected void initParams() {

   546         params = new Hashtable<Integer, Object>();

   547     }

   548 

   549     //--------------------------------------------------------------------

   550     // Events

   551     //--------------------------------------------------------------------

   552 

   553     /**

   554     * The listener will be notified whenever an event occurs on this <code>RowSet</code>

   555     * object.

   556     * <P>

   557     * A listener might, for example, be a table or graph that needs to

   558     * be updated in order to accurately reflect the current state of

   559     * the <code>RowSet</code> object.

   560     * <p>

   561     * <b>Note</b>: if the <code>RowSetListener</code> object is

   562     * <code>null</code>, this method silently discards the <code>null</code>

   563     * value and does not add a null reference to the set of listeners.

   564     * <p>

   565     * <b>Note</b>: if the listener is already set, and the new <code>RowSetListener</code>

   566     * instance is added to the set of listeners already registered to receive

   567     * event notifications from this <code>RowSet</code>.

   568     *

   569     * @param listener an object that has implemented the

   570     *     <code>javax.sql.RowSetListener</code> interface and wants to be notified

   571     *     of any events that occur on this <code>RowSet</code> object; May be

   572     *     null.

   573     * @see #removeRowSetListener

   574     */

   575     public void addRowSetListener(RowSetListener listener) {

   576         listeners.add(listener);

   577     }

   578 

   579     /**

   580     * Removes the designated object from this <code>RowSet</code> object's list of listeners.

   581     * If the given argument is not a registered listener, this method

   582     * does nothing.

   583     *

   584     *  <b>Note</b>: if the <code>RowSetListener</code> object is

   585     * <code>null</code>, this method silently discards the <code>null</code>

   586     * value.

   587     *

   588     * @param listener a <code>RowSetListener</code> object that is on the list

   589     *        of listeners for this <code>RowSet</code> object

   590     * @see #addRowSetListener

   591     */

   592     public void removeRowSetListener(RowSetListener listener) {

   593         listeners.remove(listener);

   594     }

   595 

   596     /**

   597      * Determine if instance of this class extends the RowSet interface.

   598      */

   599     private void checkforRowSetInterface() throws SQLException {

   600         if ((this instanceof javax.sql.RowSet) == false) {

   601             throw new SQLException("The class extending abstract class BaseRowSet " +

   602                 "must implement javax.sql.RowSet or one of it's sub-interfaces.");

   603         }

   604     }

   605 

   606     /**

   607     * Notifies all of the listeners registered with this

   608     * <code>RowSet</code> object that its cursor has moved.

   609     * <P>

   610     * When an application calls a method to move the cursor,

   611     * that method moves the cursor and then calls this method

   612     * internally. An application <b>should</b> never invoke

   613     * this method directly.

   614     *

   615     * @throws SQLException if the class extending the <code>BaseRowSet</code>

   616     *     abstract class does not implement the <code>RowSet</code> interface or

   617     *     one of it's sub-interfaces.

   618     */

   619     protected void notifyCursorMoved() throws SQLException {

   620         checkforRowSetInterface();

   621         if (listeners.isEmpty() == false) {

   622             RowSetEvent event = new RowSetEvent((RowSet)this);

   623             for (RowSetListener rsl : listeners) {

   624                 rsl.cursorMoved(event);

   625             }

   626         }

   627     }

   628 

   629     /**

   630     * Notifies all of the listeners registered with this <code>RowSet</code> object that

   631     * one of its rows has changed.

   632     * <P>

   633     * When an application calls a method that changes a row, such as

   634     * the <code>CachedRowSet</code> methods <code>insertRow</code>,

   635     * <code>updateRow</code>, or <code>deleteRow</code>,

   636     * that method calls <code>notifyRowChanged</code>

   637     * internally. An application <b>should</b> never invoke

   638     * this method directly.

   639     *

   640     * @throws SQLException if the class extending the <code>BaseRowSet</code>

   641     *     abstract class does not implement the <code>RowSet</code> interface or

   642     *     one of it's sub-interfaces.

   643     */

   644     protected void notifyRowChanged() throws SQLException {

   645         checkforRowSetInterface();

   646         if (listeners.isEmpty() == false) {

   647                 RowSetEvent event = new RowSetEvent((RowSet)this);

   648                 for (RowSetListener rsl : listeners) {

   649                     rsl.rowChanged(event);

   650                 }

   651         }

   652     }

   653 

   654    /**

   655     * Notifies all of the listeners registered with this <code>RowSet</code>

   656     * object that its entire contents have changed.

   657     * <P>

   658     * When an application calls methods that change the entire contents

   659     * of the <code>RowSet</code> object, such as the <code>CachedRowSet</code> methods

   660     * <code>execute</code>, <code>populate</code>, <code>restoreOriginal</code>,

   661     * or <code>release</code>, that method calls <code>notifyRowSetChanged</code>

   662     * internally (either directly or indirectly). An application <b>should</b>

   663     * never invoke this method directly.

   664     *

   665     * @throws SQLException if the class extending the <code>BaseRowSet</code>

   666     *     abstract class does not implement the <code>RowSet</code> interface or

   667     *     one of it's sub-interfaces.

   668     */

   669     protected void notifyRowSetChanged() throws SQLException {

   670         checkforRowSetInterface();

   671         if (listeners.isEmpty() == false) {

   672                 RowSetEvent event = new RowSetEvent((RowSet)this);

   673                 for (RowSetListener rsl : listeners) {

   674                     rsl.rowSetChanged(event);

   675                 }

   676         }

   677 }

   678 

   679     /**

   680      * Retrieves the SQL query that is the command for this

   681      * <code>RowSet</code> object. The command property contains the query that

   682      * will be executed to populate this <code>RowSet</code> object.

   683      * <P>

   684      * The SQL query returned by this method is used by <code>RowSet</code> methods

   685      * such as <code>execute</code> and <code>populate</code>, which may be implemented

   686      * by any class that extends the <code>BaseRowSet</code> abstract class and

   687      * implements one or more of the standard JSR-114 <code>RowSet</code>

   688      * interfaces.

   689      * <P>

   690      * The command is used by the <code>RowSet</code> object's

   691      * reader to obtain a <code>ResultSet</code> object.  The reader then

   692      * reads the data from the <code>ResultSet</code> object and uses it to

   693      * to populate this <code>RowSet</code> object.

   694      * <P>

   695      * The default value for the <code>command</code> property is <code>null</code>.

   696      *

   697      * @return the <code>String</code> that is the value for this

   698      *         <code>RowSet</code> object's <code>command</code> property;

   699      *         may be <code>null</code>

   700      * @see #setCommand

   701      */

   702     public String getCommand() {

   703         return command;

   704     }

   705 

   706     /**

   707      * Sets this <code>RowSet</code> object's <code>command</code> property to

   708      * the given <code>String</code> object and clears the parameters, if any,

   709      * that were set for the previous command.

   710      * <P>

   711      * The <code>command</code> property may not be needed if the <code>RowSet</code>

   712      * object gets its data from a source that does not support commands,

   713      * such as a spreadsheet or other tabular file.

   714      * Thus, this property is optional and may be <code>null</code>.

   715      *

   716      * @param cmd a <code>String</code> object containing an SQL query

   717      *            that will be set as this <code>RowSet</code> object's command

   718      *            property; may be <code>null</code> but may not be an empty string

   719      * @throws SQLException if an empty string is provided as the command value

   720      * @see #getCommand

   721      */

   722     public void setCommand(String cmd) throws SQLException {

   723         // cmd equal to null or

   724         // cmd with length 0 (implies url =="")

   725         // are not independent events.

   726 

   727         if(cmd == null) {

   728            command = null;

   729         } else if (cmd.length() == 0) {

   730             throw new SQLException("Invalid command string detected. " +

   731             "Cannot be of length less than 0");

   732         } else {

   733             // "unbind" any parameters from any previous command.

   734             if(params == null){

   735                  throw new SQLException("Set initParams() before setCommand");

   736             }

   737             params.clear();

   738             command = cmd;

   739         }

   740 

   741     }

   742 

   743     /**

   744      * Retrieves the JDBC URL that this <code>RowSet</code> object's

   745      * <code>javax.sql.Reader</code> object uses to make a connection

   746      * with a relational database using a JDBC technology-enabled driver.

   747      *<P>

   748      * The <code>Url</code> property will be <code>null</code> if the underlying data

   749      * source is a non-SQL data source, such as a spreadsheet or an XML

   750      * data source.

   751      *

   752      * @return a <code>String</code> object that contains the JDBC URL

   753      *         used to establish the connection for this <code>RowSet</code>

   754      *         object; may be <code>null</code> (default value) if not set

   755      * @throws SQLException if an error occurs retrieving the URL value

   756      * @see #setUrl

   757      */

   758     public String getUrl() throws SQLException {

   759         return URL;

   760     }

   761 

   762     /**

   763      * Sets the Url property for this <code>RowSet</code> object

   764      * to the given <code>String</code> object and sets the dataSource name

   765      * property to <code>null</code>. The Url property is a

   766      * JDBC URL that is used when

   767      * the connection is created using a JDBC technology-enabled driver

   768      * ("JDBC driver") and the <code>DriverManager</code>.

   769      * The correct JDBC URL for the specific driver to be used can be found

   770      * in the driver documentation.  Although there are guidelines for how

   771      * a JDBC URL is formed,

   772      * a driver vendor can specify any <code>String</code> object except

   773      * one with a length of <code>0</code> (an empty string).

   774      * <P>

   775      * Setting the Url property is optional if connections are established using

   776      * a <code>DataSource</code> object instead of the <code>DriverManager</code>.

   777      * The driver will use either the URL property or the

   778      * dataSourceName property to create a connection, whichever was

   779      * specified most recently. If an application uses a JDBC URL, it

   780      * must load a JDBC driver that accepts the JDBC URL before it uses the

   781      * <code>RowSet</code> object to connect to a database.  The <code>RowSet</code>

   782      * object will use the URL internally to create a database connection in order

   783      * to read or write data.

   784      *

   785      * @param url a <code>String</code> object that contains the JDBC URL

   786      *     that will be used to establish the connection to a database for this

   787      *     <code>RowSet</code> object; may be <code>null</code> but must not

   788      *     be an empty string

   789      * @throws SQLException if an error occurs setting the Url property or the

   790      *     parameter supplied is a string with a length of <code>0</code> (an

   791      *     empty string)

   792      * @see #getUrl

   793      */

   794     public void setUrl(String url) throws SQLException {

   795         if(url == null) {

   796            url = null;

   797         } else if (url.length() < 1) {

   798             throw new SQLException("Invalid url string detected. " +

   799             "Cannot be of length less than 1");

   800         } else {

   801             URL = url;

   802         }

   803 

   804         dataSource = null;

   805 

   806     }

   807 

   808     /**

   809      * Returns the logical name that when supplied to a naming service

   810      * that uses the Java Naming and Directory Interface (JNDI) API, will

   811      * retrieve a <code>javax.sql.DataSource</code> object. This

   812      * <code>DataSource</code> object can be used to establish a connection

   813      * to the data source that it represents.

   814      * <P>

   815      * Users should set either the url or the data source name property.

   816      * The driver will use the property set most recently to establish a

   817      * connection.

   818      *

   819      * @return a <code>String</code> object that identifies the

   820      *         <code>DataSource</code> object to be used for making a

   821      *         connection; if no logical name has been set, <code>null</code>

   822      *         is returned.

   823      * @see #setDataSourceName

   824      */

   825     public String getDataSourceName() {

   826         return dataSource;

   827     }

   828 

   829 

   830     /**

   831      * Sets the <code>DataSource</code> name property for this <code>RowSet</code>

   832      * object to the given logical name and sets this <code>RowSet</code> object's

   833      * Url property to <code>null</code>. The name must have been bound to a

   834      * <code>DataSource</code> object in a JNDI naming service so that an

   835      * application can do a lookup using that name to retrieve the

   836      * <code>DataSource</code> object bound to it. The <code>DataSource</code>

   837      * object can then be used to establish a connection to the data source it

   838      * represents.

   839      * <P>

   840      * Users should set either the Url property or the dataSourceName property.

   841      * If both properties are set, the driver will use the property set most recently.

   842      *

   843      * @param name a <code>String</code> object with the name that can be supplied

   844      *     to a naming service based on JNDI technology to retrieve the

   845      *     <code>DataSource</code> object that can be used to get a connection;

   846      *     may be <code>null</code> but must not be an empty string

   847      * @throws SQLException if an empty string is provided as the <code>DataSource</code>

   848      *    name

   849      * @see #getDataSourceName

   850      */

   851     public void setDataSourceName(String name) throws SQLException {

   852 

   853         if (name == null) {

   854             dataSource = null;

   855         } else if (name.equals("")) {

   856            throw new SQLException("DataSource name cannot be empty string");

   857         } else {

   858            dataSource = name;

   859         }

   860 

   861         URL = null;

   862     }

   863 

   864     /**

   865      * Returns the user name used to create a database connection.  Because it

   866      * is not serialized, the username property is set at runtime before

   867      * calling the method <code>execute</code>.

   868      *

   869      * @return the <code>String</code> object containing the user name that

   870      *         is supplied to the data source to create a connection; may be

   871      *         <code>null</code> (default value) if not set

   872      * @see #setUsername

   873      */

   874     public String getUsername() {

   875         return username;

   876     }

   877 

   878     /**

   879      * Sets the username property for this <code>RowSet</code> object

   880      * to the given user name. Because it

   881      * is not serialized, the username property is set at run time before

   882      * calling the method <code>execute</code>.

   883      *

   884      * @param name the <code>String</code> object containing the user name that

   885      *     is supplied to the data source to create a connection. It may be null.

   886      * @see #getUsername

   887      */

   888     public void setUsername(String name) {

   889         if(name == null)

   890         {

   891            username = null;

   892         } else {

   893            username = name;

   894         }

   895     }

   896 

   897     /**

   898      * Returns the password used to create a database connection for this

   899      * <code>RowSet</code> object.  Because the password property is not

   900      * serialized, it is set at run time before calling the method

   901      * <code>execute</code>. The default value is <code>null</code>

   902      *

   903      * @return the <code>String</code> object that represents the password

   904      *         that must be supplied to the database to create a connection

   905      * @see #setPassword

   906      */

   907     public String getPassword() {

   908         return password;

   909     }

   910 

   911     /**

   912      * Sets the password used to create a database connection for this

   913      * <code>RowSet</code> object to the given <code>String</code>

   914      * object.  Because the password property is not

   915      * serialized, it is set at run time before calling the method

   916      * <code>execute</code>.

   917      *

   918      * @param pass the <code>String</code> object that represents the password

   919      *     that is supplied to the database to create a connection. It may be

   920      *     null.

   921      * @see #getPassword

   922      */

   923     public void setPassword(String pass) {

   924         if(pass == null)

   925         {

   926            password = null;

   927         } else {

   928            password = pass;

   929         }

   930     }

   931 

   932     /**

   933      * Sets the type for this <code>RowSet</code> object to the specified type.

   934      * The default type is <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>.

   935      *

   936      * @param type one of the following constants:

   937      *             <code>ResultSet.TYPE_FORWARD_ONLY</code>,

   938      *             <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or

   939      *             <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>

   940      * @throws SQLException if the parameter supplied is not one of the

   941      *         following constants:

   942      *          <code>ResultSet.TYPE_FORWARD_ONLY</code> or

   943      *          <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>

   944      *          <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>

   945      * @see #getConcurrency

   946      * @see #getType

   947      */

   948     public void setType(int type) throws SQLException {

   949 

   950         if ((type != ResultSet.TYPE_FORWARD_ONLY) &&

   951            (type != ResultSet.TYPE_SCROLL_INSENSITIVE) &&

   952            (type != ResultSet.TYPE_SCROLL_SENSITIVE)) {

   953                 throw new SQLException("Invalid type of RowSet set. Must be either " +

   954                 "ResultSet.TYPE_FORWARD_ONLY or ResultSet.TYPE_SCROLL_INSENSITIVE " +

   955                 "or ResultSet.TYPE_SCROLL_SENSITIVE.");

   956         }

   957         this.rowSetType = type;

   958     }

   959 

   960     /**

   961      * Returns the type of this <code>RowSet</code> object. The type is initially

   962      * determined by the statement that created the <code>RowSet</code> object.

   963      * The <code>RowSet</code> object can call the method

   964      * <code>setType</code> at any time to change its

   965      * type.  The default is <code>TYPE_SCROLL_INSENSITIVE</code>.

   966      *

   967      * @return the type of this JDBC <code>RowSet</code>

   968      *         object, which must be one of the following:

   969      *         <code>ResultSet.TYPE_FORWARD_ONLY</code>,

   970      *         <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or

   971      *         <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>

   972      * @throws SQLException if an error occurs getting the type of

   973      *     of this <code>RowSet</code> object

   974      * @see #setType

   975      */

   976     public int getType() throws SQLException {

   977         return rowSetType;

   978     }

   979 

   980     /**

   981      * Sets the concurrency for this <code>RowSet</code> object to

   982      * the specified concurrency. The default concurrency for any <code>RowSet</code>

   983      * object (connected or disconnected) is <code>ResultSet.CONCUR_UPDATABLE</code>,

   984      * but this method may be called at any time to change the concurrency.

   985      *

   986      * @param concurrency one of the following constants:

   987      *                    <code>ResultSet.CONCUR_READ_ONLY</code> or

   988      *                    <code>ResultSet.CONCUR_UPDATABLE</code>

   989      * @throws SQLException if the parameter supplied is not one of the

   990      *         following constants:

   991      *          <code>ResultSet.CONCUR_UPDATABLE</code> or

   992      *          <code>ResultSet.CONCUR_READ_ONLY</code>

   993      * @see #getConcurrency

   994      * @see #isReadOnly

   995      */

   996     public void setConcurrency(int concurrency) throws SQLException {

   997 

   998         if((concurrency != ResultSet.CONCUR_READ_ONLY) &&

   999            (concurrency != ResultSet.CONCUR_UPDATABLE)) {

  1000                 throw new SQLException("Invalid concurrency set. Must be either " +

  1001                 "ResultSet.CONCUR_READ_ONLY or ResultSet.CONCUR_UPDATABLE.");

  1002         }

  1003         this.concurrency = concurrency;

  1004     }

  1005 

  1006     /**

  1007      * Returns a <code>boolean</code> indicating whether this

  1008      * <code>RowSet</code> object is read-only.

  1009      * Any attempts to update a read-only <code>RowSet</code> object will result in an

  1010      * <code>SQLException</code> being thrown. By default,

  1011      * rowsets are updatable if updates are possible.

  1012      *

  1013      * @return <code>true</code> if this <code>RowSet</code> object

  1014      *         cannot be updated; <code>false</code> otherwise

  1015      * @see #setConcurrency

  1016      * @see #setReadOnly

  1017      */

  1018     public boolean isReadOnly() {

  1019         return readOnly;

  1020     };

  1021 

  1022     /**

  1023      * Sets this <code>RowSet</code> object's readOnly  property to the given <code>boolean</code>.

  1024      *

  1025      * @param value <code>true</code> to indicate that this

  1026      *              <code>RowSet</code> object is read-only;

  1027      *              <code>false</code> to indicate that it is updatable

  1028      */

  1029     public void setReadOnly(boolean value) {

  1030         readOnly = value;

  1031     }

  1032 

  1033     /**

  1034      * Returns the transaction isolation property for this

  1035      * <code>RowSet</code> object's connection. This property represents

  1036      * the transaction isolation level requested for use in transactions.

  1037      * <P>

  1038      * For <code>RowSet</code> implementations such as

  1039      * the <code>CachedRowSet</code> that operate in a disconnected environment,

  1040      * the <code>SyncProvider</code> object

  1041      * offers complementary locking and data integrity options. The

  1042      * options described below are pertinent only to connected <code>RowSet</code>

  1043      * objects (<code>JdbcRowSet</code> objects).

  1044      *

  1045      * @return one of the following constants:

  1046      *         <code>Connection.TRANSACTION_NONE</code>,

  1047      *         <code>Connection.TRANSACTION_READ_UNCOMMITTED</code>,

  1048      *         <code>Connection.TRANSACTION_READ_COMMITTED</code>,

  1049      *         <code>Connection.TRANSACTION_REPEATABLE_READ</code>, or

  1050      *         <code>Connection.TRANSACTION_SERIALIZABLE</code>

  1051      * @see javax.sql.rowset.spi.SyncFactory

  1052      * @see javax.sql.rowset.spi.SyncProvider

  1053      * @see #setTransactionIsolation

  1054 

  1055      */

  1056     public int getTransactionIsolation() {

  1057         return isolation;

  1058     };

  1059 

  1060     /**

  1061      * Sets the transaction isolation property for this JDBC <code>RowSet</code> object to the given

  1062      * constant. The DBMS will use this transaction isolation level for

  1063      * transactions if it can.

  1064      * <p>

  1065      * For <code>RowSet</code> implementations such as

  1066      * the <code>CachedRowSet</code> that operate in a disconnected environment,

  1067      * the <code>SyncProvider</code> object being used

  1068      * offers complementary locking and data integrity options. The

  1069      * options described below are pertinent only to connected <code>RowSet</code>

  1070      * objects (<code>JdbcRowSet</code> objects).

  1071      *

  1072      * @param level one of the following constants, listed in ascending order:

  1073      *              <code>Connection.TRANSACTION_NONE</code>,

  1074      *              <code>Connection.TRANSACTION_READ_UNCOMMITTED</code>,

  1075      *              <code>Connection.TRANSACTION_READ_COMMITTED</code>,

  1076      *              <code>Connection.TRANSACTION_REPEATABLE_READ</code>, or

  1077      *              <code>Connection.TRANSACTION_SERIALIZABLE</code>

  1078      * @throws SQLException if the given parameter is not one of the Connection

  1079      *          constants

  1080      * @see javax.sql.rowset.spi.SyncFactory

  1081      * @see javax.sql.rowset.spi.SyncProvider

  1082      * @see #getTransactionIsolation

  1083      */

  1084     public void setTransactionIsolation(int level) throws SQLException {

  1085         if ((level != Connection.TRANSACTION_NONE) &&

  1086            (level != Connection.TRANSACTION_READ_COMMITTED) &&

  1087            (level != Connection.TRANSACTION_READ_UNCOMMITTED) &&

  1088            (level != Connection.TRANSACTION_REPEATABLE_READ) &&

  1089            (level != Connection.TRANSACTION_SERIALIZABLE))

  1090             {

  1091                 throw new SQLException("Invalid transaction isolation set. Must " +

  1092                 "be either " +

  1093                 "Connection.TRANSACTION_NONE or " +

  1094                 "Connection.TRANSACTION_READ_UNCOMMITTED or " +

  1095                 "Connection.TRANSACTION_READ_COMMITTED or " +

  1096                 "Connection.TRANSACTION_REPEATABLE_READ or " +

  1097                 "Connection.TRANSACTION_SERIALIZABLE");

  1098             }

  1099         this.isolation = level;

  1100     }

  1101 

  1102     /**

  1103      * Retrieves the type map associated with the <code>Connection</code>

  1104      * object for this <code>RowSet</code> object.

  1105      * <P>

  1106      * Drivers that support the JDBC 3.0 API will create

  1107      * <code>Connection</code> objects with an associated type map.

  1108      * This type map, which is initially empty, can contain one or more

  1109      * fully-qualified SQL names and <code>Class</code> objects indicating

  1110      * the class to which the named SQL value will be mapped. The type mapping

  1111      * specified in the connection's type map is used for custom type mapping

  1112      * when no other type map supersedes it.

  1113      * <p>

  1114      * If a type map is explicitly supplied to a method that can perform

  1115      * custom mapping, that type map supersedes the connection's type map.

  1116      *

  1117      * @return the <code>java.util.Map</code> object that is the type map

  1118      *         for this <code>RowSet</code> object's connection

  1119      */

  1120     public java.util.Map<String,Class<?>> getTypeMap() {

  1121         return map;

  1122     }

  1123 

  1124     /**

  1125      * Installs the given <code>java.util.Map</code> object as the type map

  1126      * associated with the <code>Connection</code> object for this

  1127      * <code>RowSet</code> object.  The custom mapping indicated in

  1128      * this type map will be used unless a different type map is explicitly

  1129      * supplied to a method, in which case the type map supplied will be used.

  1130      *

  1131      * @param map a <code>java.util.Map</code> object that contains the

  1132      *     mapping from SQL type names for user defined types (UDT) to classes in

  1133      *     the Java programming language.  Each entry in the <code>Map</code>

  1134      *     object consists of the fully qualified SQL name of a UDT and the