Overview | Package | Class | Use | Tree | Deprecated | Index | Help
|  | Oracle
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## weblogic.jdbc.rowset
Interface WLRowSetMetaData

All Superinterfaces:
  ResultSetMetaData, RowSetMetaData, Wrapper

    public interface WLRowSetMetaData

extends RowSetMetaData

WLRowSetMetaData extends the `javax.sql.RowSetMetaData` interface with extended meta-data methods.

The RowSet uses Optimistic concurrency control to maintain consistency between the time the data is read and when it is updated most likely in a separate transaction.

The descriptions of the optimistic concurrency policy options (such as VERIFY_READ_COLUMNS, VERIFY_MODIFIED_COLUMNS, etc.) use this simple table to demonstrate the behavior of each. The examples assume the RowSet contains all columns from this database table. Some options also use an additional e_version column.

     create table employees(
       e_id integer primary key,
       e_first varchar(25),
       e_last varchar(25),
       e_salary integer
     );

     Assume that this table has a single row:
     e_id = 1
     e_first = "John"
     e_last = "Doe"
     e_salary = 10000

Field Summary
`static int` | `VERIFY_AUTO_VERSION_COLUMNS` The VERIFY_AUTO_VERSION_COLUMNS option includes the primary key columns and specified version columns in the WHERE clause.
`static int` | `VERIFY_MODIFIED_COLUMNS` The VERIFY_MODIFIED_COLUMNS only verifies the modified columns during the update.
`static int` | `VERIFY_NONE` The VERIFY_NONE option only includes the primary key columns in the WHERE clause.
`static int` | `VERIFY_READ_COLUMNS` The VERIFY_READ_COLUMNS optimistic concurrency policy includes all values read into the WLCachedRowSet in the where clause when changes are written back to the database.
`static int` | `VERIFY_SELECTED_COLUMNS` The VERIFY_SELECTED_COLUMNS only verifies specified columns and the primary key columns during the update.
`static int` | `VERIFY_VERSION_COLUMNS` The VERIFY_VERSION_COLUMNS option includes the primary key columns and specified version columns in the WHERE clause.

Fields inherited from interface java.sql.ResultSetMetaData
`columnNoNulls, columnNullable, columnNullableUnknown`

Method Summary
`int` | `findColumn(String n)` Returns the column index for the specified column name.
`boolean` | `getBatchDeletes()` Returns the current batch delete setting.
`boolean` | `getBatchInserts()` Returns the current batch insert setting.
`boolean` | `getBatchUpdates()` Returns the current batch update setting.
`int` | `getBatchVerifySize()` Returns the current batch verify size.
`String` | `getDefaultNamespace()` Returns the XML schema's default namespace for this RowSet.
`boolean` | `getGroupDeletes()` Returns the current group deletes setting.
`int` | `getGroupDeleteSize()` Returns the current group delete size.
`int` | `getOptimisticPolicy()` Returns the current optimistic concurrency policy.
`String` | `getOptimisticPolicyAsString()` Returns the current optimistic policy as a String
`String` | `getQualifiedTableName(int i)` getQualifiedTableName behaves like getTableName; however, if the catalog and/or schema name have been set then getQualifiedTableName returns catalog.schema.column.
`String` | `getQualifiedTableName(String n)` getQualifiedTableName behaves like getTableName; however, if the catalog and/or schema name have been set then getQualifiedTableName returns catalog.schema.column.
`String` | `getRowName()` Returns the name of the Row element in the schema and instance.
`String` | `getRowSetName()` Returns the name of the Row Set in the schema and instance.
`boolean` | `getVerboseSQL()` Returns the current verbose SQL setting
`String` | `getWriteColumnName(int i)` Returns the write column name for the specified column.
`String` | `getWriteColumnName(String colName)` Returns the write column name for the specified column.
`String` | `getWriteTableName()` Returns the write table name.
`String` | `getXMLSchemaLocation()` Returns the schemaLocation attribute which instance documents will use to refer to this schema document.
`boolean` | `haveSetPKColumns()` Indicates whether `setPrimaryKeyColumn` has been called on any of the columns.
`boolean` | `isAutoVersionColumn(int i)` Indicates whether the column will be used for a VERIFY_AUTO_VERSION_COLUMNS verification.
`boolean` | `isAutoVersionColumn(String colName)` Indicates whether the column will be used for a VERIFY_AUTO_VERSION_COLUMNS verification.
`boolean` | `isPrimaryKeyColumn(int i)` Indicates whether the column is a primary key column.
`boolean` | `isPrimaryKeyColumn(String colName)` Indicates whether the column is a primary key column.
`boolean` | `isReadOnly()` Indicates whether the entire RowSet is ReadOnly.
`boolean` | `isReadOnly(String colName)` Indicates whether the column is marked read-only.
`boolean` | `isSelectedColumn(int i)` Indicates whether the column will be used for a VERIFY_SELECTED_COLUMNS verification.
`boolean` | `isSelectedColumn(String colName)` Indicates whether the column will be used for a VERIFY_SELECTED_COLUMNS verification.
`boolean` | `isVersionColumn(int i)` Indicates whether the column will be used for a VERIFY_VERSION_COLUMNS verification.
`boolean` | `isVersionColumn(String colName)` Indicates whether the column will be used for a VERIFY_VERSION_COLUMNS verification.
`void` | `loadXMLSchema(XMLInputStream xis)` Loads the WLRowSetMetaData from an XML Schema document in the XMLInputStream.
`void` | `markUpdateProperties(String writeTableName, String pkColumn, String rowVersionColumn)` markUpdateProperties is a convenience method for indicating the writeTableName, a single primary key column, and a row version column.
`void` | `setAutoVersionColumn(int i, boolean b)` Sets a column to be a version column.
`void` | `setAutoVersionColumn(String colName, boolean b)` Sets a column to be a version column.
`void` | `setBatchDeletes(boolean b)` Sets whether DELETE statements should use a JDBC batch statement or should be issued as individual DELETE statements.
`void` | `setBatchInserts(boolean b)` Sets whether INSERT statements should use a JDBC batch statement or should be issued as individual INSERT statements.
`void` | `setBatchUpdates(boolean b)` Sets whether UPDATE statements should use a JDBC batch statement or should be issued as individual UPDATE statements.
`void` | `setBatchVerifySize(int size)` When batched updates and enabled and the database/driver do not return the updated row counts from batched statements, an extra select query is issued prior to the batched updates to ensure there is no optimistic conflict.
`void` | `setDefaultNamespace(String namespace)` Sets the XML schema's default namespace for this RowSet.
`void` | `setGroupDeletes(boolean b)` Sets the RowSet to use group deletes.
`void` | `setGroupDeleteSize(int size)` Sets the number of rows sent in an individual delete statement.
`void` | `setOptimisticPolicy(int policy)` Sets the optimistic concurrency policy for updates
`void` | `setOptimisticPolicyAsString(String policy)` Sets the optimistic concurrency policy for updates
`void` | `setPrimaryKeyColumn(int i, boolean b)` Sets the column to be a primary key column.
`void` | `setPrimaryKeyColumn(String colName, boolean b)` Sets the column to be a primary key column.
`void` | `setReadOnly(boolean b)` Sets the entire RowSet to be ReadOnly.
`void` | `setReadOnly(int i, boolean b)` Sets the column to be a read-only column.
`void` | `setReadOnly(String colName, boolean b)` Sets the column to be a read-only column.
`void` | `setRowName(String rowName)` Sets the name of the Row element in the schema and instance.
`void` | `setRowSetName(String rowSetName)` Sets the name of the Row Set in the schema and instance.
`void` | `setTableName(String tableName)` Sets the table name for all columns.
`void` | `setTableName(String colName, String tableName)` Sets the table name for the specified column.
`void` | `setVerboseSQL(boolean b)` Enables/disables printing of the executed SQL statements to System.out.
`void` | `setVerifySelectedColumn(int i, boolean b)` Sets a column to be verified during the update.
`void` | `setVerifySelectedColumn(String colName, boolean b)` Sets a column to be verified during the update.
`void` | `setVersionColumn(int i, boolean b)` Sets a column to be a version column.
`void` | `setVersionColumn(String colName, boolean b)` Sets a column to be a version column.
`void` | `setWriteColumnName(int i, String writeColumnName)` Sets the write column name for the specified column.
`void` | `setWriteColumnName(String colName, String writeColumnName)` Sets the write column name for the specified column.
`void` | `setWriteTableName(String writeTableName)` Sets a table to be the write table.
`void` | `setXMLSchemaLocation(String location)` Sets the schemaLocation attribute which instance documents will use to refer to this schema document.
`void` | `writeXMLSchema(XMLOutputStream xos)` Writes the WLRowSetMetaData as an XML Schema document to the specified XMLOutputStream.

Methods inherited from interface javax.sql.RowSetMetaData
`setAutoIncrement, setCaseSensitive, setCatalogName, setColumnCount, setColumnDisplaySize, setColumnLabel, setColumnName, setColumnType, setColumnTypeName, setCurrency, setNullable, setPrecision, setScale, setSchemaName, setSearchable, setSigned, setTableName`

Methods inherited from interface java.sql.ResultSetMetaData
`getCatalogName, getColumnClassName, getColumnCount, getColumnDisplaySize, getColumnLabel, getColumnName, getColumnType, getColumnTypeName, getPrecision, getScale, getSchemaName, getTableName, isAutoIncrement, isCaseSensitive, isCurrency, isDefinitelyWritable, isNullable, isReadOnly, isSearchable, isSigned, isWritable`

Methods inherited from interface java.sql.Wrapper
`isWrapperFor, unwrap`

Field Detail

### VERIFY_READ_COLUMNS

    static final int VERIFY_READ_COLUMNS

  The VERIFY_READ_COLUMNS optimistic concurrency policy includes all values read into the WLCachedRowSet in the where clause when changes are written back to the database. This is the default policy. This is the default policy. With this option, the where clause in the update or delete statement includes all of the values which were read into the WLCachedRowSet. The update or delete will only succeed if the underlying data has not changed since being read from the database.

  For instance, if the RowSet attempts to update John Doe's salary to 20000, it will issue:

  UPDATE SET e_salary=20000 WHERE e_id=1 AND e_first='John' AND e_last='Doe' AND e_salary=10000

  See Also:
    Constant Field Values

### VERIFY_MODIFIED_COLUMNS

    static final int VERIFY_MODIFIED_COLUMNS

  The VERIFY_MODIFIED_COLUMNS only verifies the modified columns during the update. The update statement's WHERE clause will include the primary key columns and the modified columns.

  For instance, if the RowSet attempts to update John Doe's salary to 20000, it will issue:

  UPDATE SET e_salary=20000 WHERE e_id=1 AND e_salary=10000

  See Also:
    `WLRowSetMetaData.setOptimisticPolicy(int)`, `WLRowSetMetaData.setOptimisticPolicyAsString(java.lang.String)`, Constant Field Values

### VERIFY_SELECTED_COLUMNS

    static final int VERIFY_SELECTED_COLUMNS

  The VERIFY_SELECTED_COLUMNS only verifies specified columns and the primary key columns during the update. The user must have called setVerifySelectedColumn and WLRowSetMetaData.setPrimaryKeyColumn to mark the appropriate columns before calling `acceptChanges`.

  This method is used when the application wants complete control to customize which columns are verified.

  For instance, if the RowSet attempts to update John Doe's salary to 20000 and setVerifySelectedColumn("e_first") has been called, it will issue:

  UPDATE SET e_salary=20000 WHERE e_id=1 AND e_first='John'

  See Also:
    `WLRowSetMetaData.setOptimisticPolicy(int)`, `WLRowSetMetaData.setOptimisticPolicyAsString(java.lang.String)`, Constant Field Values

### VERIFY_NONE

    static final int VERIFY_NONE

  The VERIFY_NONE option only includes the primary key columns in the WHERE clause. It does not perform any data verification.

  For instance, if the RowSet attempts to update John Doe's salary to 20000, it will issue:

  UPDATE SET e_salary=20000 WHERE e_id=1

  See Also:
    `WLRowSetMetaData.setOptimisticPolicy(int)`, `WLRowSetMetaData.setOptimisticPolicyAsString(java.lang.String)`, Constant Field Values

### VERIFY_AUTO_VERSION_COLUMNS

    static final int VERIFY_AUTO_VERSION_COLUMNS

  The VERIFY_AUTO_VERSION_COLUMNS option includes the primary key columns and specified version columns in the WHERE clause. It checks during acceptChanges that the version columns have not changed since the rowset was populated. The WLRowSetMetaData.setAutoVersionColumn method must be called to indicate the version columns. The version columns must be integers.

  The VERIFY_AUTO_VERSION_COLUMNS automatically updates the version columns to the next increasing value

  UPDATE SET e_salary=20000, e_version=2 WHERE e_id=1 AND e_version=1

  See Also:
    `WLRowSetMetaData.setOptimisticPolicy(int)`, `WLRowSetMetaData.setOptimisticPolicyAsString(java.lang.String)`, Constant Field Values

### VERIFY_VERSION_COLUMNS

    static final int VERIFY_VERSION_COLUMNS

  The VERIFY_VERSION_COLUMNS option includes the primary key columns and specified version columns in the WHERE clause. It checks during acceptChanges that the version columns have not changed since the rowset was populated. The WLRowSetMetaData.setVersionColumn method must be called to indicate the version columns.

  The database must handle updating the version column to a new value. Some databases provide support for a version type that will automatically be updated, but it is also possible to write a database trigger to update the version column.

  UPDATE SET e_salary=20000 WHERE e_id=1 AND e_version=1

  See Also:
    `WLRowSetMetaData.setOptimisticPolicy(int)`, `WLRowSetMetaData.setOptimisticPolicyAsString(java.lang.String)`, Constant Field Values

Method Detail

### getOptimisticPolicy

    int getOptimisticPolicy()

  Returns the current optimistic concurrency policy.

  Possible values are:

  1 = VERIFY_READ_COLUMNS (the default)
  2 = VERIFY_MODIFIED_COLUMNS
  3 = VERIFY_SELECTED_COLUMNS
  4 = VERIFY_NONE
  5 = VERIFY_AUTO_VERSION_COLUMNS
  6 = VERIFY_VERSION_COLUMNS

  Returns:
    current optimistic policy

### getOptimisticPolicyAsString

    String getOptimisticPolicyAsString()

  Returns the current optimistic policy as a String

### setOptimisticPolicy

    void setOptimisticPolicy(int policy)
                             throws SQLException

  Sets the optimistic concurrency policy for updates

  Possible values are:

  1 = VERIFY_READ_COLUMNS (the default)
  2 = VERIFY_MODIFIED_COLUMNS
  3 = VERIFY_SELECTED_COLUMNS
  4 = VERIFY_NONE
  5 = VERIFY_AUTO_VERSION_COLUMNS
  6 = VERIFY_VERSION_COLUMNS

  setOptimisticPolicy must be called before calling `acceptChanges`.

  Throws:
    `SQLException` - thrown if the policy is not a legal value

### setOptimisticPolicyAsString

    void setOptimisticPolicyAsString(String policy)
                                     throws SQLException

  Sets the optimistic concurrency policy for updates

  Possible values are:

  VERIFY_READ_COLUMNS (the default)

  VERIFY_MODIFIED_COLUMNS

  VERIFY_SELECTED_COLUMNS

  VERIFY_NONE

  VERIFY_AUTO_VERSION_COLUMNS

  VERIFY_VERSION_COLUMNS

  setOptimisticPolicy must be called before calling `acceptChanges`.

  Throws:
    `SQLException` - thrown if the policy is not a legal value

### setBatchInserts

    void setBatchInserts(boolean b)

  Sets whether INSERT statements should use a JDBC batch statement or should be issued as individual INSERT statements. Using batch inserts leads to better performance when multiple inserts are done in a single RowSet.

  Batch inserts require a JDBC 2.0 or later driver that supports the java.sql.PreparedStatement.addBatch method

  By default, batch inserts are not enabled.

### getBatchInserts

    boolean getBatchInserts()

  Returns the current batch insert setting.

  By default, batch inserts are not enabled.

  Returns:
    the current batch insert setting

### setBatchDeletes

    void setBatchDeletes(boolean b)

  Sets whether DELETE statements should use a JDBC batch statement or should be issued as individual DELETE statements. Using batch deletes leads to better performance when multiple deletes are done in a single RowSet.

  Batch deletes require a JDBC 2.0 or later driver that supports the java.sql.PreparedStatement.addBatch method

  By default, batch deletes are not enabled.

### getBatchDeletes

    boolean getBatchDeletes()

  Returns the current batch delete setting.

  By default, batch deletes are not enabled.

  Returns:
    the current batch delete setting

### setBatchUpdates

    void setBatchUpdates(boolean b)

  Sets whether UPDATE statements should use a JDBC batch statement or should be issued as individual UPDATE statements. Using batch updates leads to better performance when multiple updates with the same SQL but different parameters are done in a single acceptChanges call

  Batch updates require a JDBC 2.0 or later driver that supports the java.sql.PreparedStatement.addBatch method

  By default, batch updates are not enabled.

### getBatchUpdates

    boolean getBatchUpdates()

  Returns the current batch update setting.

  By default, batch updates are not enabled.

  Returns:
    the current batch update setting

### setVerboseSQL

    void setVerboseSQL(boolean b)

  Enables/disables printing of the executed SQL statements to System.out. By default, verbose sql is off.

### getVerboseSQL

    boolean getVerboseSQL()

  Returns the current verbose SQL setting

  Returns:
    the current verbose SQL setting

### setGroupDeletes

    void setGroupDeletes(boolean b)

  Sets the RowSet to use group deletes. With group deletes, the rowset issues SQL statements where the WHERE clause includes several deleted rows. For instance, the rowset would normally issue: DELETE FROM employees WHERE id = 1; DELETE FROM employees WHERE id = 2; When group deletes are enabled, it will issue: DELETE FROM employees WHERE id = 1 OR id = 2;

### getGroupDeletes

    boolean getGroupDeletes()

  Returns the current group deletes setting. By default, group deletes are enabled.

  Returns:
    the current group deletes setting

### setGroupDeleteSize

    void setGroupDeleteSize(int size)
                            throws SQLException

  Sets the number of rows sent in an individual delete statement. Tuning this larger produces less database round-trips but larger SQL statements. The default value is 50.

  Throws:
    `SQLException` - if the size is <= 0

### getGroupDeleteSize

    int getGroupDeleteSize()

  Returns the current group delete size.

  Returns:
    the current group delete size

### setBatchVerifySize

    void setBatchVerifySize(int size)
                            throws SQLException

  When batched updates and enabled and the database/driver do not return the updated row counts from batched statements, an extra select query is issued prior to the batched updates to ensure there is no optimistic conflict. This parameter determines the number of rows included in each select statement. This parameter is only used when batched updates are used with an Oracle database. The default value is 50.

  Throws:
    `SQLException` - if the size is <= 0

### getBatchVerifySize

    int getBatchVerifySize()

  Returns the current batch verify size.

  Returns:
    the current batch verify size

### findColumn

    int findColumn(String n)
                   throws SQLException

  Returns the column index for the specified column name.

  Returns:
    the column index for the specified column name
  Throws:
    `SQLException` - if the column name is not in the RowSet

### getQualifiedTableName

    String getQualifiedTableName(String n)
                                 throws SQLException

  getQualifiedTableName behaves like getTableName; however, if the catalog and/or schema name have been set then getQualifiedTableName returns catalog.schema.column. For instance, if the schema name was "test" and the table name "products", getTableName would return "products", but getQualifiedTableName returns "test.products"

  Returns:
    fully qualified table name
  Throws:
    `SQLException`

### getQualifiedTableName

    String getQualifiedTableName(int i)
                                 throws SQLException

  getQualifiedTableName behaves like getTableName; however, if the catalog and/or schema name have been set then getQualifiedTableName returns catalog.schema.column. For instance, if the schema name was "test" and the table name "products", getTableName would return "products", but getQualifiedTableName returns "test.products"

  Returns:
    fully qualified table name
  Throws:
    `SQLException`

### setTableName

    void setTableName(String tableName)
                      throws SQLException

  Sets the table name for all columns. This method should be called after data has been read into the RowSet.

  The RowSet implementation will attempt to infer table names when it is populated with data. However, many JDBC drivers do not implement `java.sql.ResultSetMetaData.getTable`, so it is usually required to call setTableName before writing the RowSet's data.

  Throws:
    `SQLException`

### setTableName

    void setTableName(String colName,
                      String tableName)
                      throws SQLException

  Sets the table name for the specified column. This method should be called after data has been read into the RowSet.

  The RowSet implementation will attempt to infer table names when it is populated with data. However, many JDBC drivers do not implement `java.sql.ResultSetMetaData.getTable` so it is usually required to call setTableName before writing the RowSet's data.

  Throws:
    `SQLException`

### setPrimaryKeyColumn

    void setPrimaryKeyColumn(int i,
                             boolean b)
                             throws SQLException

  Sets the column to be a primary key column.

  Marking a column to be a primary key automatically marks it as read-only. To update a primary key column, it is necessary to explicitly call setReadOnly(col, false) after setPrimaryKeyColumn.

  Parameters:
    `i` - column number
    `b` - isPrimaryKey
  Throws:
    `SQLException`

### setPrimaryKeyColumn

    void setPrimaryKeyColumn(String colName,
                             boolean b)
                             throws SQLException

  Sets the column to be a primary key column.

  Marking a column to be a primary key automatically marks it as read-only. To update a primary key column, it is necessary to explicitly call setReadOnly(col, false) after setPrimaryKeyColumn.

  Parameters:
    `colName` - column name
    `b` - isPrimaryKey
  Throws:
    `SQLException`

### isPrimaryKeyColumn

    boolean isPrimaryKeyColumn(int i)
                               throws SQLException

  Indicates whether the column is a primary key column.

  Parameters:
    `i` - column number
  Returns:
    isPrimaryKeyColumn
  Throws:
    `SQLException`

### isPrimaryKeyColumn

    boolean isPrimaryKeyColumn(String colName)
                               throws SQLException

  Indicates whether the column is a primary key column.

  Parameters:
    `colName` - column name
  Returns:
    isPrimaryKeyColumn
  Throws:
    `SQLException`

### haveSetPKColumns

    boolean haveSetPKColumns()

  Indicates whether `setPrimaryKeyColumn` has been called on any of the columns.

  This is generally useful for a RowSetWriter implementation which requires the user to set primary key columns to determine whether this has occurred.

  Returns:
    if setPrimaryKeyColumn has been called

### isReadOnly

    boolean isReadOnly(String colName)
                       throws SQLException

  Indicates whether the column is marked read-only.

  Parameters:
    `colName` - column name
  Returns:
    isReadOnly
  Throws:
    `SQLException`

### setReadOnly

    void setReadOnly(int i,
                     boolean b)
                     throws SQLException

  Sets the column to be a read-only column.

  Parameters:
    `i` - column number
    `b` - isReadOnly
  Throws:
    `SQLException`

### setReadOnly

    void setReadOnly(String colName,
                     boolean b)
                     throws SQLException

  Sets the column to be a read-only column.

  Parameters:
    `colName` - column name
    `b` - isReadOnly
  Throws:
    `SQLException`

### isReadOnly

    boolean isReadOnly()
                       throws SQLException

  Indicates whether the entire RowSet is ReadOnly.

  Returns:
    isReadOnly
  Throws:
    `SQLException`

### setReadOnly

    void setReadOnly(boolean b)
                     throws SQLException

  Sets the entire RowSet to be ReadOnly.

  Parameters:
    `b` - isReadOnly
  Throws:
    `SQLException`

### setVerifySelectedColumn

    void setVerifySelectedColumn(int i,
                                 boolean b)
                                 throws SQLException

  Sets a column to be verified during the update. This method is only used when the VERIFY_SELECTED_COLUMNS optimistic policy is being used.

  Parameters:
    `i` - column number
    `b` - isVerifiedColumn
  Throws:
    `SQLException`

### isSelectedColumn

    boolean isSelectedColumn(int i)
                             throws SQLException

  Indicates whether the column will be used for a VERIFY_SELECTED_COLUMNS verification.

  Returns:
    true if setVerifySelectedColumn(i, true) has been called.
  Throws:
    `SQLException`

### isSelectedColumn

    boolean isSelectedColumn(String colName)
                             throws SQLException

  Indicates whether the column will be used for a VERIFY_SELECTED_COLUMNS verification.

  Returns:
    true if setVerifySelectedColumn(colName, true) has been called.
  Throws:
    `SQLException`

### setVerifySelectedColumn

    void setVerifySelectedColumn(String colName,
                                 boolean b)
                                 throws SQLException

  Sets a column to be verified during the update. This method is only used when the VERIFY_SELECTED_COLUMNS optimistic policy is being used.

  Parameters:
    `colName` - column name
    `b` - isVerifiedColumn
  Throws:
    `SQLException`

### setAutoVersionColumn

    void setAutoVersionColumn(int i,
                              boolean b)
                              throws SQLException

  Sets a column to be a version column. This method is only used when the VERIFY_AUTO_VERSION_COLUMNS optimistic policy is being used.

  Parameters:
    `i` - column number
    `b` - isVersionColumn
  Throws:
    `SQLException`

### setAutoVersionColumn

    void setAutoVersionColumn(String colName,
                              boolean b)
                              throws SQLException

  Sets a column to be a version column. This method is only used when the VERIFY_AUTO_VERSION_COLUMNS optimistic policy is being used.

  Parameters:
    `colName` - column name
    `b` - isVersionColumn
  Throws:
    `SQLException`

### isAutoVersionColumn

    boolean isAutoVersionColumn(String colName)
                                throws SQLException

  Indicates whether the column will be used for a VERIFY_AUTO_VERSION_COLUMNS verification.

  Returns:
    true if setAutoVersionColumn(colName, true) has been called.
  Throws:
    `SQLException`

### isAutoVersionColumn

    boolean isAutoVersionColumn(int i)
                                throws SQLException

  Indicates whether the column will be used for a VERIFY_AUTO_VERSION_COLUMNS verification.

  Returns:
    true if setAutoVersionColumn(i, true) has been called.
  Throws:
    `SQLException`

### setVersionColumn

    void setVersionColumn(int i,
                          boolean b)
                          throws SQLException

  Sets a column to be a version column. This method is only used when the VERIFY_VERSION_COLUMNS optimistic policy is being used.

  Parameters:
    `i` - column number
    `b` - isVersionColumn
  Throws:
    `SQLException`

### setVersionColumn

    void setVersionColumn(String colName,
                          boolean b)
                          throws SQLException

  Sets a column to be a version column. This method is only used when the VERIFY_VERSION_COLUMNS optimistic policy is being used.

  Parameters:
    `colName` - column name
    `b` - isVersionColumn
  Throws:
    `SQLException`

### isVersionColumn

    boolean isVersionColumn(String colName)
                            throws SQLException

  Indicates whether the column will be used for a VERIFY_VERSION_COLUMNS verification.

  Returns:
    true if setVersionColumn(colName, true) has been called.
  Throws:
    `SQLException`

### isVersionColumn

    boolean isVersionColumn(int i)
                            throws SQLException

  Indicates whether the column will be used for a VERIFY_VERSION_COLUMNS verification.

  Returns:
    true if setVersionColumn(i, true) has been called.
  Throws:
    `SQLException`

### setWriteTableName

    void setWriteTableName(String writeTableName)
                           throws SQLException

  Sets a table to be the write table.

  The write table is the only table that can be updated or deleted.

  This is typically used when a RowSet is populated via a join from multiple tables, but the rowset should only update one table.

  Any column which is not from the write table is marked as read-only.

  For instance, a rowset might include a join of orders and customers. The write table could be set to orders. If deleteRow were called, it would delete the order row, but not delete the customer row.

  Parameters:
    `writeTableName` - the write table name
  Throws:
    `SQLException`

### getWriteTableName

    String getWriteTableName()

  Returns the write table name. By default, the write table name is null and all tables in the rowset are writable.

  Returns:
    the write table name

### markUpdateProperties

    void markUpdateProperties(String writeTableName,
                              String pkColumn,
                              String rowVersionColumn)
                              throws SQLException

  markUpdateProperties is a convenience method for indicating the writeTableName, a single primary key column, and a row version column. It is equivalent to doing:

       setTableName(writeTableName);
       setWriteTableName(writeTableName);
       setPrimaryKeyColumn(findColumn(pkColumn), true);
       setOptimisticPolicy(VERIFY_VERSION_COLUMNS);
       setVersionColumn(findColumn(rowVersionColumn), true);

  Throws:
    `SQLException`

### getWriteColumnName

    String getWriteColumnName(int i)
                              throws SQLException

  Returns the write column name for the specified column. The write column name is the column name used in update statements. By default the write column name is the same as the column name. The write column name may be set to a different value with setWriteColumnName. This is commonly done when queries like SELECT colName as alias ... are done. In this case, the rowset only sees the column alias and needs the writeColumnName to be set to the actual column name for updates to be successful.

  Parameters:
    `i` - column number
  Returns:
    writeColumnName
  Throws:
    `SQLException`

### getWriteColumnName

    String getWriteColumnName(String colName)
                              throws SQLException

  Returns the write column name for the specified column. The write column name is the column name used in update statements.

  By default the write column name is the same as the column name.

  The write column name may be set to a different value with setWriteColumnName. This is commonly done when queries like SELECT colName as alias ... are done. In this case, the rowset only sees the column alias and needs the writeColumnName to be set to the actual column name for updates to be successful.

  Parameters:
    `colName` - column name
  Returns:
    writeColumnName
  Throws:
    `SQLException`

### setWriteColumnName

    void setWriteColumnName(int i,
                            String writeColumnName)
                            throws SQLException

  Sets the write column name for the specified column. The write column name is the column name used in update statements.

  By default the write column name is the same as the column name.

  The write column name may be set to a different value with setWriteColumnName. This is commonly done when queries like SELECT colName as alias ... are done. In this case, the rowset only sees the column alias and needs the writeColumnName to be set to the actual column name for updates to be successful.

  Parameters:
    `i` - column number
    `writeColumnName` - write column name
  Throws:
    `SQLException`

### setWriteColumnName

    void setWriteColumnName(String colName,
                            String writeColumnName)
                            throws SQLException

  Sets the write column name for the specified column. The write column name is the column name used in update statements.

  By default the write column name is the same as the column name.

  The write column name may be set to a different value with setWriteColumnName. This is commonly done when queries like SELECT colName as alias ... are done. In this case, the rowset only sees the column alias and needs the writeColumnName to be set to the actual column name for updates to be successful.

  Parameters:
    `colName` - column name
    `writeColumnName` - write column name
  Throws:
    `SQLException`

### setDefaultNamespace

    void setDefaultNamespace(String namespace)

  Sets the XML schema's default namespace for this RowSet.

  Parameters:
    `String` - default namespace

### getDefaultNamespace

    String getDefaultNamespace()

  Returns the XML schema's default namespace for this RowSet. The default value is http://www.openuri.org

  Returns:
    default namespace

### setRowName

    void setRowName(String rowName)

  Sets the name of the Row element in the schema and instance.

  Parameters:
    `the` - row name

### getRowName

    String getRowName()

  Returns the name of the Row element in the schema and instance.

  The default value is getWriteTableName() + "Row". If the write table name has not been set, it defaults to "TableRow".

  Returns:
    the name of the Row element in the schema and instance

### setRowSetName

    void setRowSetName(String rowSetName)

  Sets the name of the Row Set in the schema and instance.

  Parameters:
    `the` - row set name

### getRowSetName

    String getRowSetName()

  Returns the name of the Row Set in the schema and instance.

  The default value is getRowName() + "Set"

  Returns:
    the name of the Row Set in the schema and instance

### writeXMLSchema

    void writeXMLSchema(XMLOutputStream xos)
                        throws IOException,
                               SQLException

  Writes the WLRowSetMetaData as an XML Schema document to the specified XMLOutputStream.

  Throws:
    `IOException`
    `SQLException`

### loadXMLSchema

    void loadXMLSchema(XMLInputStream xis)
                       throws IOException,
                              SQLException

  Loads the WLRowSetMetaData from an XML Schema document in the XMLInputStream.

  Throws:
    `IOException`
    `SQLException`

### getXMLSchemaLocation

    String getXMLSchemaLocation()

  Returns the schemaLocation attribute which instance documents will use to refer to this schema document.

  The default value is: getDefaultNamespace()+"/" + getRowSetName()+".xsd"

### setXMLSchemaLocation

    void setXMLSchemaLocation(String location)

  Sets the schemaLocation attribute which instance documents will use to refer to this schema document.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| Documentation is available at http://edocs.bea.com/wls/docs103 Copyright 1996,2008, Oracle and/or its affiliates. All rights reserved. Oracle is a registered trademark of Oracle Corporation and/or its affiliates. Other names may be trademarks of their respective owners.
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD