jdbcResultSet(Result r,
    HsqlProperties props) throws SQLException 
{
        connProperties = props;
        if (props != null) {
            getColumnName = props.isPropertyTrue("jdbc.get_column_name",
                                                 true);
            strictMetaData = props.isPropertyTrue("jdbc.strict_md", false);
        }
        if (r.iMode == Result.UPDATECOUNT) {
            iUpdateCount = r.iUpdateCount;
        } else if (r.iMode == Result.ERROR) {
// fredt@users 20020221 - patch 513005 by sqlbob@users (RMP)
// tony_lai@users 20020820 - patch 595073
//            throw (Trace.getError(r.errorCode, r.sError));
            throw (Trace.getError(r.sError, r.errorCode));
        } else {
            iUpdateCount = -1;
            rResult      = r;
            iColumnCount = r.getColumnCount();
        }
        bWasNull = false;
}

Constructs a new jdbcResultSet object using the specified org.hsqldb.Result.

Parameters:

r - the internal result form that the new jdbcResultSet represents

Throws:

SQLException - when the supplied Result is of type org.hsqldb.Result.ERROR

exception: SQLException - when the supplied Result is of type org.hsqldb.Result.ERROR

 public boolean absolute(int row) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        if (this.getType() == TYPE_FORWARD_ONLY) {
            throw Trace.error(Trace.RESULTSET_FORWARD_ONLY);
        }
        if (rResult == null) {
            return false;
        }
        if ((rResult.rRoot == null) || (row == 0)) {
            // No rows in the resultset or tried to execute absolute(0)
            // which is not valid
            return false;
        }
        // A couple of special cases
        switch (row) {
            case 1 :
                return first();    // absolute(1) is same as first()
            case -1 :
                return last();     // absolute(-1) is same as last()
        }
        // If the row variable is negative, calculate the target
        // row from the end of the resultset.
        if (row <  0) {
            // we know there are rows in resultset, so get the last
            last();
            // calculate the target row
            row = iCurrentRow + row + 1;
            // Exit if the target row is before the beginning of the resultset
            if (row < = 0) {
                beforeFirst();
                return false;
            }
        }
        if ((row <  iCurrentRow) || (iCurrentRow == 0)) {
            // Need to go back and start from the beginning of the resultset
            beforeFirst();
        }
        // go to the tagget row;
        while (row  > iCurrentRow) {
            next();
            if (nCurrent == null) {
                break;
            }
        }
        return nCurrent != null;
}

Moves the cursor to the given row number in this ResultSet object.

If the row number is positive, the cursor moves to the given row number with respect to the beginning of the result set. The first row is row 1, the second is row 2, and so on.

If the given row number is negative, the cursor moves to an absolute row position with respect to the end of the result set. For example, calling the method absolute(-1) positions the cursor on the last row; calling the method absolute(-2) moves the cursor to the next-to-last row, and so on.

An attempt to position the cursor beyond the first/last row in the result set leaves the cursor before the first row or after the last row.

Note: Calling absolute(1) is the same as calling first(). Calling absolute(-1) is the same as calling last().

 public  void afterLast() throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        if (this.getType() == TYPE_FORWARD_ONLY) {
            throw Trace.error(Trace.RESULTSET_FORWARD_ONLY);
        }
        if (rResult != null) {
            if (rResult.rRoot != null) {
                // not and empty resultset, so set the afterLast status
                bInit       = true;
                iCurrentRow = 0;
                nCurrent    = null;
            }
        }
}

Moves the cursor to the end of this ResultSet object, just after the last row. This method has no effect if the result set contains no rows.

 public  void beforeFirst() throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        if (this.getType() == TYPE_FORWARD_ONLY) {
            throw Trace.error(Trace.RESULTSET_FORWARD_ONLY);
        }
        // Set to beforeFirst status
        bInit       = false;
        nCurrent    = null;
        iCurrentRow = 0;
}

Moves the cursor to the front of this ResultSet object, just before the first row. This method has no effect if the result set contains no rows.

 public  void cancelRowUpdates() throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        throw getNotSupported();
}

Cancels the updates made to the current row in this ResultSet object. This method may be called after calling an updater method(s) and before calling the method updateRow to roll back the updates made to a row. If no updates have been made or updateRow has already been called, this method has no effect.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void clearWarnings() throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
}

Clears all warnings reported on this ResultSet object. After this method is called, the method getWarnings returns null until a new warning is reported for this ResultSet object.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not produce SQLWarning objects, so this method is simply ignored.

 public  void close() throws SQLException 
{
        iUpdateCount = -1;
        rResult      = null;
}

Releases this ResultSet object's database and JDBC resources immediately instead of waiting for this to happen when it is automatically closed.

Note: A ResultSet object is automatically closed by the Statement object that generated it when that Statement object is closed, re-executed, or is used to retrieve the next result from a sequence of multiple results. A ResultSet object is also automatically closed when it is garbage collected.

 public  void deleteRow() throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        throw getNotSupported();
}

Deletes the current row from this ResultSet object and from the underlying database. This method cannot be called when the cursor is on the insert row.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

Calling this method always throws a SQLException, stating that the function is not supported.

 public int findColumn(String columnName) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace(columnName);
        }
        for (int i = 0; i <  iColumnCount; i++) {
            if (columnName.equalsIgnoreCase(rResult.sLabel[i])) {
                return i + 1;
            }
        }
        throw Trace.error(Trace.COLUMN_NOT_FOUND);
}

Maps the given ResultSet column name to its ResultSet column index.

 public boolean first() throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        if (this.getType() == TYPE_FORWARD_ONLY) {
            throw Trace.error(Trace.RESULTSET_FORWARD_ONLY);
        }
        if (rResult == null) {
            return false;
        }
        bInit = false;
        if (rResult.rRoot != null) {
            bInit       = true;
            nCurrent    = rResult.rRoot;
            iCurrentRow = 1;
        }
        return bInit;
}

Moves the cursor to the first row in this ResultSet object.

 public Array getArray(int i) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        throw getNotSupported();
}

Retrieves the value of the designated column in the current row of this ResultSet object as an Array object in the Java programming language.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support this feature.

Calling this method always throws a SQLException, stating that the function is not supported.

 public Array getArray(String colName) throws SQLException 
{
        return getArray(findColumn(colName));
}

Retrieves the value of the designated column in the current row of this ResultSet object as an Array object in the Java programming language.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support this feature.

Calling this method always throws a SQLException, stating that the function is not supported.

 public InputStream getAsciiStream(int columnIndex) throws SQLException 
{
        String s = getString(columnIndex);
        if (s == null) {
            return null;
        }
        return new AsciiStringInputStream(s);
}

Retrieves the value of the designated column in the current row of this ResultSet object as a stream of ASCII characters. The value can then be read in chunks from the stream. This method is particularly suitable for retrieving large LONGVARCHAR values. The JDBC driver will do any necessary conversion from the database format into ASCII.

Note: All the data in the returned stream must be read prior to getting the value of any other column. The next call to a getter method implicitly closes the stream. Also, a stream may return 0 when the method InputStream.available is called whether there is data available or not.

HSQLDB-Specific Information:

The limitation noted above does not apply to HSQLDB.

Up to and including 1.6.1, getAsciiStream was identical to getUnicodeStream and both simply returned a byte stream constructed from the raw getBytes representation. Starting with 1.7.0, this has been updated to comply with the java.sql specification. When the column is of type CHAR and its variations, it requires no conversion since it is represented internally already as Java Strings. When the column is not of type CHAR and its variations, the returned stream is based on a conversion to the Java String representation of the value. In either case, the obtained stream is always equivalent to a stream of the low order bytes from the value's String representation.

HSQLDB SQL CHAR and its variations are all Unicode strings internally, so the recommended alternatives to this method are getString , getUnicodeStream (deprecated) and new to 1.7.0: getCharacterStream (now prefered over the deprecated getUnicodeStream alternative).

 public InputStream getAsciiStream(String columnName) throws SQLException 
{
        return getAsciiStream(findColumn(columnName));
}

Retrieves the value of the designated column in the current row of this ResultSet object as a stream of ASCII characters. The value can then be read in chunks from the stream. This method is particularly suitable for retrieving large LONGVARCHAR values. The JDBC driver will do any necessary conversion from the database format into ASCII.

Note: All the data in the returned stream must be read prior to getting the value of any other column. The next call to a getter method implicitly closes the stream. Also, a stream may return 0 when the method available is called whether there is data available or not.

 public BigDecimal getBigDecimal(int columnIndex) throws SQLException 
{
        return (BigDecimal) getColumnInType(columnIndex, Types.DECIMAL);
}

Retrieves the value of the designated column in the current row of this ResultSet object as a java.math.BigDecimal with full precision.

 public BigDecimal getBigDecimal(String columnName) throws SQLException 
{
        return getBigDecimal(findColumn(columnName));
}

Retrieves the value of the designated column in the current row of this ResultSet object as a java.math.BigDecimal with full precision.

 public BigDecimal getBigDecimal(int columnIndex,
    int scale) throws SQLException 
{
        // boucherb@users 20020502 - added conversion
        BigDecimal bd = (BigDecimal) getColumnInType(columnIndex,
            Types.DECIMAL);
        if (scale <  0) {
            throw Trace.error(Trace.INVALID_JDBC_ARGUMENT);
        }
        if (bd != null) {
            bd.setScale(scale, BigDecimal.ROUND_HALF_DOWN);
        }
        return bd;
}

Retrieves the value of the designated column in the current row of this ResultSet object as a java.sql.BigDecimal in the Java programming language.

HSQLDB-Specific Information:

Beginning with 1.7.0, HSQLDB converts the result and sets the scale with BigDecimal.ROUND_HALF_DOWN

 public BigDecimal getBigDecimal(String columnName,
    int scale) throws SQLException 
{
        return getBigDecimal(findColumn(columnName), scale);
}

Retrieves the value of the designated column in the current row of this ResultSet object as a java.math.BigDecimal in the Java programming language.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB ignores the scale parameter.

 public InputStream getBinaryStream(int columnIndex) throws SQLException 
{
        byte[] b = getBytes(columnIndex);
        return wasNull() ? null
                         : new ByteArrayInputStream(b);
        // or new ByteArrayInputStream(new byte[0]) : ...
}

Retrieves the value of the designated column in the current row of this ResultSet object as a binary stream of uninterpreted bytes. The value can then be read in chunks from the stream. This method is particularly suitable for retrieving large LONGVARBINARY values.

Note: All the data in the returned stream must be read prior to getting the value of any other column. The next call to a getter method implicitly closes the stream. Also, a stream may return 0 when the method InputStream.available is called whether there is data available or not.

 public InputStream getBinaryStream(String columnName) throws SQLException 
{
        return getBinaryStream(findColumn(columnName));
}

Retrieves the value of the designated column in the current row of this ResultSet object as a stream of uninterpreted bytes. The value can then be read in chunks from the stream. This method is particularly suitable for retrieving large LONGVARBINARY values.

Note: All the data in the returned stream must be read prior to getting the value of any other column. The next call to a getter method implicitly closes the stream. Also, a stream may return 0 when the method available is called whether there is data available or not.

 public Blob getBlob(int i) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        throw getNotSupported();
}

Retrieves the value of the designated column in the current row of this ResultSet object as a Blob object in the Java programming language.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support this feature.

Calling this method always throws a SQLException, stating that the function is not supported.

 public Blob getBlob(String colName) throws SQLException 
{
        return getBlob(findColumn(colName));
}

Retrieves the value of the designated column in the current row of this ResultSet object as a Blob object in the Java programming language.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support this feature.

Calling this method always throws a SQLException, stating that the function is not supported.

 public boolean getBoolean(int columnIndex) throws SQLException 
{
        Object o = getColumnInType(columnIndex, Types.BIT);
        return o == null ? false
                         : ((Boolean) o).booleanValue();
}

Retrieves the value of the designated column in the current row of this ResultSet object as a boolean in the Java programming language.

 public boolean getBoolean(String columnName) throws SQLException 
{
        return getBoolean(findColumn(columnName));
}

Retrieves the value of the designated column in the current row of this ResultSet object as a boolean in the Java programming language.

 public byte getByte(int columnIndex) throws SQLException 
{
        Object o = getColumnInType(columnIndex, Types.SMALLINT);
        return o == null ? 0
                         : ((Number) o).byteValue();
}

Retrieves the value of the designated column in the current row of this ResultSet object as a byte in the Java programming language.

 public byte getByte(String columnName) throws SQLException 
{
        return getByte(findColumn(columnName));
}

Retrieves the value of the designated column in the current row of this ResultSet object as a byte in the Java programming language.

 public byte[] getBytes(int columnIndex) throws SQLException 
{
        Object x = getObject(columnIndex);
        if (x == null) {
            return null;
        }
        if (x instanceof byte[]) {
            return (byte[]) x;
        }
        if (x instanceof java.lang.String) {
            return ((String) x).getBytes();
        }
        x = getColumnInType(--columnIndex, Types.BINARY);
        return (byte[]) x;
}

Retrieves the value of the designated column in the current row of this ResultSet object as a byte array in the Java programming language. The bytes represent the raw values returned by the driver.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB returns correct values for columns of type BINARY, CHAR and their variations. For other types, it returns the byte[] for the String representation of the value.

 public byte[] getBytes(String columnName) throws SQLException 
{
        return getBytes(findColumn(columnName));
}

Retrieves the value of the designated column in the current row of this ResultSet object as a byte array in the Java programming language. The bytes represent the raw values returned by the driver.

 public String getCatalogName(int column) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        checkColumn(column);
        return "";
}

Gets the designated column's table's catalog name.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDD does not support catalogs.

This method always returns an empty String.

See discussion at: #getMetaData

 public Reader getCharacterStream(int columnIndex) throws SQLException 
{
        String s = getString(columnIndex);
        if (s == null) {
            return null;
        }
        return new StringReader(s);
}

Retrieves the value of the designated column in the current row of this ResultSet object as a java.io.Reader object.

HSQLDB-Specific Information:

This method is new to HSQLDB 1.7.0. Previous versions did not implement this, thowing a SQLException instead.

 public Reader getCharacterStream(String columnName) throws SQLException 
{
        return getCharacterStream(findColumn(columnName));
}

Retrieves the value of the designated column in the current row of this ResultSet object as a java.io.Reader object.

HSQLDB-Specific Information:

This method is new to HSQLDB 1.7.0. Previous versions did not implement this, thowing a SQLException instead.

 public Clob getClob(int i) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        throw getNotSupported();
}

Retrieves the value of the designated column in the current row of this ResultSet object as a Clob object in the Java programming language.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support this feature.

Calling this method always throws a SQLException, stating that the function is not supported.

 public Clob getClob(String colName) throws SQLException 
{
        return getClob(findColumn(colName));
}

Retrieves the value of the designated column in the current row of this ResultSet object as a Clob object in the Java programming language.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support this feature.

Calling this method always throws a SQLException, stating that the function is not supported.

 public String getColumnClassName(int column) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        // fredt@users - 20020413
        // need a reverse mapping list between SQL and Java types used
        // in HSQLDB.
        throw getNotSupported();
}

Returns the fully-qualified name of the Java class whose instances are manufactured if the method ResultSet.getObject is called to retrieve a value from the column. ResultSet.getObject may return a subclass of the class returned by this method.

HSQLDB-Specific Information:

HSQLDB 1.7.1 does not support this feature.

Calling this method always throws a SQLException, stating that the function is not supported.

See discussion at: #getMetaData

 public int getColumnCount() throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        return iColumnCount;
}

Returns the number of columns in this ResultSet object.

HSQLDB-Specific Information:

See discussion at: #getMetaData

 public int getColumnDisplaySize(int column) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        checkColumn(column);
        // Some program expect that this is the maximum allowed length
        // for this column, so it is dangerous to return the size required
        // to display all records
        return 0;
}

Indicates the designated column's normal maximum width in characters.

HSQLDB-Specific Information:

Up to and including HSQLDB 1.7.0, this method always returns 0 (no limit/unknown).

See discussion at: #getMetaData

 public String getColumnLabel(int column) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        checkColumn(column);
        return rResult.sLabel[--column];
}

Gets the designated column's suggested title for use in printouts and displays.

HSQLDB-Specific Information:

In HSQLDB a ResultSet column label is determined in the following order of precedence:

1. The label (alias) specified in the generating query.
2. The name of the underlying column, if no label is specified.
   This also applies to aggregate functions.
3. An empty String.

See discussion at: #getMetaData

 public String getColumnName(int column) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        checkColumn(column);
        if (getColumnName) {
            return rResult.sName[--column];
        } else {
            return rResult.sLabel[--column];
        }
}

Get the designated column's name.

HSQLDB-Specific Information:

In HSQLDB a ResultSet column name is determined in the following order of prcedence:

1. The name of the underlying columnm, if the ResultSet column represents a column in a table.
2. The label or alias specified in the generating query.
3. An empty String.

If the jdbc.get_column_name property of the database has been set to false, this method returns the same value as #getColumnLabel(int) .

See discussion at: #getMetaData

 public int getColumnType(int column) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        checkColumn(column);
        return rResult.colType[--column];
}

Retrieves the designated column's SQL type.

HSQLDB-Specific Information:

This reports the SQL type of the column. HSQLDB can return Objects in any Java integral type wider than Integer for an SQL integral type.

See discussion at: #getMetaData

 public String getColumnTypeName(int column) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        checkColumn(column);
        return Column.getTypeString(rResult.colType[--column]);
}

Retrieves the designated column's database-specific type name.

HSQLDB-Specific Information:

See above at: (@link #getColumnType)

See discussion at: #getMetaData

 public int getConcurrency() throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        return CONCUR_READ_ONLY;
}

Retrieves the concurrency mode of this ResultSet object. The concurrency used is determined by the Statement object that created the result set.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB supports only and thus always returns CONCUR_READ_ONLY.

 public String getCursorName() throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        throw getNotSupported();
}

Retrieves the name of the SQL cursor used by this ResultSet object.

In SQL, a result table is retrieved through a cursor that is named. The current row of a result set can be updated or deleted using a positioned update/delete statement that references the cursor name. To insure that the cursor has the proper isolation level to support update, the cursor's SELECT statement should be of the form SELECT FOR UPDATE. If FOR UPDATE is omitted, the positioned updates may fail.

The JDBC API supports this SQL feature by providing the name of the SQL cursor used by a ResultSet object. The current row of a ResultSet object is also the current row of this SQL cursor.

Note: If positioned update is not supported, a SQLException is thrown.

HSQLDB-Specific Information:

HSQLDB 1.7.1 does not support this feature.

Calling this method always throws a SQLException, stating that the function is not supported.

 public Date getDate(int columnIndex) throws SQLException 
{
        return (java.sql.Date) getColumnInType(columnIndex, Types.DATE);
}

Retrieves the value of the designated column in the current row of this ResultSet object as a java.sql.Date object in the Java programming language.

 public Date getDate(String columnName) throws SQLException 
{
        return getDate(findColumn(columnName));
}

Retrieves the value of the designated column in the current row of this ResultSet object as a java.sql.Date object in the Java programming language.

 public Date getDate(int columnIndex,
    Calendar cal) throws SQLException 
{
        // ADDED:
        // to be consistent:  this was missing
        // boucherb@users 20020413
        // TODO: implement, based on new jdbcPreparedStatement code
        // and change documentation to reflect
        if (Trace.TRACE) {
            Trace.trace();
        }
        throw getNotSupported();
}

Retrieves the value of the designated column in the current row of this ResultSet object as a java.sql.Date object in the Java programming language. This method uses the given calendar to construct an appropriate millisecond value for the date if the underlying database does not store timezone information.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support this feature.

Calling this method always throws a SQLException, stating that the function is not supported.

 public Date getDate(String columnName,
    Calendar cal) throws SQLException 
{
        // MODIFIED:
        // made this consistent with our other
        // column name oriented methods
        // boucherb@users 20020413
        return getDate(findColumn(columnName), cal);
}

Retrieves the value of the designated column in the current row of this ResultSet object as a java.sql.Date object in the Java programming language. This method uses the given calendar to construct an appropriate millisecond value for the date if the underlying database does not store timezone information.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support this feature.

Calling this method always throws a SQLException, stating that the function is not supported.

 public double getDouble(int columnIndex) throws SQLException 
{
        Object o = getColumnInType(columnIndex, Types.DOUBLE);
        return o == null ? 0.0
                         : ((Number) o).doubleValue();
}

Retrieves the value of the designated column in the current row of this ResultSet object as a double in the Java programming language.

 public double getDouble(String columnName) throws SQLException 
{
        return getDouble(findColumn(columnName));
}

Retrieves the value of the designated column in the current row of this ResultSet object as a double in the Java programming language.

 public int getFetchDirection() throws SQLException 
{
        return FETCH_FORWARD;
}

Retrieves the fetch direction for this ResultSet object.

HSQLDB-Specific Information:

HSQLDB 1.7.1 returns result sets as a whole, so the value returned by this method has no real meaning.

Calling this method always returns FETCH_FORWARD.

 public int getFetchSize() throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        return 1;
}

Retrieves the fetch size for this ResultSet object.

HSQLDB-Specific Information:

As HSQLDB builds and returns the whole result set as a whole, the value returned (1) has no significance.

 public float getFloat(int columnIndex) throws SQLException 
{
        Object o = getColumnInType(columnIndex, Types.REAL);
        return o == null ? (float) 0.0
                         : ((Number) o).floatValue();
}

Retrieves the value of the designated column in the current row of this ResultSet object as a float in the Java programming language.

 public float getFloat(String columnName) throws SQLException 
{
        return getFloat(findColumn(columnName));
}

Retrieves the value of the designated column in the current row of this ResultSet object as a float in the Java programming language.

 public int getInt(int columnIndex) throws SQLException 
{
        Object o = getColumnInType(columnIndex, Types.INTEGER);
        return o == null ? 0
                         : ((Number) o).intValue();
}

Retrieves the value of the designated column in the current row of this ResultSet object as an int in the Java programming language.

 public int getInt(String columnName) throws SQLException 
{
        return getInt(findColumn(columnName));
}

Retrieves the value of the designated column in the current row of this ResultSet object as an int in the Java programming language.

 public long getLong(int columnIndex) throws SQLException 
{
        Object o = getColumnInType(columnIndex, Types.BIGINT);
        return o == null ? 0
                         : ((Number) o).longValue();
}

Retrieves the value of the designated column in the current row of this ResultSet object as a long in the Java programming language.

 public long getLong(String columnName) throws SQLException 
{
        return getLong(findColumn(columnName));
}

Retrieves the value of the designated column in the current row of this ResultSet object as a long in the Java programming language.

 public ResultSetMetaData getMetaData() throws SQLException 
{
        return this;
}

Retrieves the number, types and properties of this ResultSet object's columns.

HSQLDB-Specific Information:

jdbcResultSet implements both the ResultSet and ResultSetMetaData interfaces. However, to gain access to the interface methods of ResultSetMetaData in a driver independent way, the traditional call to this method should be used, rather than casting objects known to be of type jdbcResultSet to type ResultSetMetaData.

Example:

The following code fragment creates a ResultSet object rs, creates a ResultSetMetaData object rsmd, and uses rsmd to find out how many columns rs has and whether the first column in rs can be used in a WHERE clause.

ResultSet rs = stmt.executeQuery ( "SELECT a, b, c FROM TABLE2");
ResultSetMetaData rsmd = rs.getMetaData();
int numberOfColumns = rsmd.getColumnCount();
boolean b = rsmd.isSearchable(1);


Warning:

Up to and including 1.7.1, HSQLDB does not generate accurate ResultSetMetaData. Below are the points to consider:

1. #isCurrency always returns false
2. #isNullable always returns columnNullableUnknown
3. #getColumnDisplaySize returns zero for all valid column numbers
4. #getSchemaName always returns ""
5. #getPrecision always returns zero
6. #getScale always returns zero
7. #getCatalogName always returns ""

 public Object getObject(int columnIndex) throws SQLException 
{
        checkAvailable();
        Object o;
        try {
            o = nCurrent.data[--columnIndex];
        } catch (ArrayIndexOutOfBoundsException e) {
            throw Trace.error(Trace.COLUMN_NOT_FOUND, ++columnIndex);
        }
        // use checknull because getColumnInType is not used
        checkNull(o);
// fredt@users 20020328 -  patch 482109 by fredt - OBJECT handling
// all objects are stored in Result as the original java object,
// except byte[] which is wrapped in ByteArray to allow comparison.
// Deserialization of OTHER is now handled in BinaryServerRowInput
// when reconstructing a Result from a bytestream.
        return o;
}

Gets the value of the designated column in the current row of this ResultSet object as an Object in the Java programming language.

This method will return the value of the given column as a Java object. The type of the Java object will be the default Java object type corresponding to the column's SQL type, following the mapping for built-in types specified in the JDBC specification. If the value is an SQL NULL, the driver returns a Java null.

This method may also be used to read datatabase-specific abstract data types. In the JDBC 2.0 API, the behavior of method getObject is extended to materialize data of SQL user-defined types. When a column contains a structured or distinct value, the behavior of this method is as if it were a call to: getObject(columnIndex, this.getStatement().getConnection().getTypeMap()).

 public Object getObject(String columnName) throws SQLException 
{
        return getObject(findColumn(columnName));
}

Gets the value of the designated column in the current row of this ResultSet object as an Object in the Java programming language.

This method will return the value of the given column as a Java object. The type of the Java object will be the default Java object type corresponding to the column's SQL type, following the mapping for built-in types specified in the JDBC specification. If the value is an SQL NULL, the driver returns a Java null.

This method may also be used to read datatabase-specific abstract data types.

In the JDBC 2.0 API, the behavior of the method getObject is extended to materialize data of SQL user-defined types. When a column contains a structured or distinct value, the behavior of this method is as if it were a call to: getObject(columnIndex, this.getStatement().getConnection().getTypeMap()).

 public Object getObject(int i,
    Map map) throws SQLException 
{
        // ADDED:
        // trace was missing.
        // boucherb@users 20020413
        if (Trace.TRACE) {
            Trace.trace();
        }
        throw getNotSupported();
}

Retrieves the value of the designated column in the current row of this ResultSet object as an Object in the Java programming language. If the value is an SQL NULL, the driver returns a Java null. This method uses the given Map object for the custom mapping of the SQL structured or distinct type that is being retrieved.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support this feature.

Calling this method always throws a SQLException, stating that the function is not supported.

 public Object getObject(String colName,
    Map map) throws SQLException 
{
        // MODIFIED:
        // made this consistent with all other
        // column name oriented methods
        // boucherb@users 2002013
        return getObject(findColumn(colName), map);
}

Retrieves the value of the designated column in the current row of this ResultSet object as an Object in the Java programming language. If the value is an SQL NULL, the driver returns a Java null. This method uses the specified Map object for custom mapping if appropriate.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support this feature.

Calling this method always throws a SQLException, stating that the function is not supported.

 public int getPrecision(int column) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        checkColumn(column);
        return 0;
}

Get the designated column's number of decimal digits.

HSQLDB-Specific Information:

Up to and including HSQLDB 1.7.0, this method always returns 0 (unknown/no limit).

See discussion at: #getMetaData

 public Ref getRef(int i) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        throw getNotSupported();
}

Retrieves the value of the designated column in the current row of this ResultSet object as a Ref object in the Java programming language.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support this feature.

Calling this method always throws a SQLException, stating that the function is not supported.

 public Ref getRef(String colName) throws SQLException 
{
        return getRef(findColumn(colName));
}

Retrieves the value of the designated column in the current row of this ResultSet object as a Ref object in the Java programming language.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support this feature.

Calling this method always throws a SQLException, stating that the function is not supported.

 public int getRow() throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        return iCurrentRow;
}

Retrieves the current row number. The first row is number 1, the second number 2, and so on.

 public int getScale(int column) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        checkColumn(column);
        return 0;
}

Gets the designated column's number of digits to right of the decimal point.

HSQLDB-Specific Information:

Up to and including HSQLDB 1.7.0, this method always returns 0 (unknown).

See discussion at: #getMetaData

 public String getSchemaName(int column) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        checkColumn(column);
        return "";
}

Get the designated column's table's schema.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDD does not support schema names.

This method always returns an empty String.

See discussion at: #getMetaData

 public short getShort(int columnIndex) throws SQLException 
{
        Object o = getColumnInType(columnIndex, Types.SMALLINT);
        return o == null ? 0
                         : ((Number) o).shortValue();
}

Retrieves the value of the designated column in the current row of this ResultSet object as a short in the Java programming language.

 public short getShort(String columnName) throws SQLException 
{
        return getShort(findColumn(columnName));
}

Retrieves the value of the designated column in the current row of this ResultSet object as a short in the Java programming language.

 public Statement getStatement() throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        return sqlStatement;
}

Retrieves the Statement object that produced this ResultSet object. If the result set was generated some other way, such as by a DatabaseMetaData method, this method returns null.

 public String getString(int columnIndex) throws SQLException 
{
        checkAvailable();
        Object o;
        try {
            o = nCurrent.data[--columnIndex];
        } catch (ArrayIndexOutOfBoundsException e) {
            throw Trace.error(Trace.COLUMN_NOT_FOUND, ++columnIndex);
        }
        // use checknull because getColumnInType is not used
        checkNull(o);
        return o == null ? null
                         : o.toString();
}

Retrieves the value of the designated column in the current row of this ResultSet object as a String in the Java programming language.

 public String getString(String columnName) throws SQLException 
{
        return getString(findColumn(columnName));
}

Retrieves the value of the designated column in the current row of this ResultSet object as a String in the Java programming language.

 public String getTableName(int column) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        checkColumn(column);
        return rResult.sTable[--column];
}

Gets the designated column's table name.

HSQLDB-Specific Information:

See discussion at: #getMetaData

 public Time getTime(int columnIndex) throws SQLException 
{
        return (Time) getColumnInType(columnIndex, Types.TIME);
}

Retrieves the value of the designated column in the current row of this ResultSet object as a java.sql.Time object in the Java programming language.

 public Time getTime(String columnName) throws SQLException 
{
        return getTime(findColumn(columnName));
}

Retrieves the value of the designated column in the current row of this ResultSet object as a java.sql.Time object in the Java programming language.

 public Time getTime(int columnIndex,
    Calendar cal) throws SQLException 
{
        // ADDED:
        // trace to be consistent:  this was missing
        // boucherb@users 20020413
        // TODO: implement, based on new jdbcPreparedStatement code
        // and change documentation to reflect
        if (Trace.TRACE) {
            Trace.trace();
        }
        throw getNotSupported();
}

Retrieves the value of the designated column in the current row of this ResultSet object as a java.sql.Time object in the Java programming language. This method uses the given calendar to construct an appropriate millisecond value for the time if the underlying database does not store timezone information.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support this feature.

Calling this method always throws a SQLException, stating that the function is not supported.

 public Time getTime(String columnName,
    Calendar cal) throws SQLException 
{
        // MODIFIED:
        // to be consistent with our
        // other column name oriented methods
        // boucherb@users 20020413
        return getTime(findColumn(columnName), cal);
}

Retrieves the value of the designated column in the current row of this ResultSet object as a java.sql.Time object in the Java programming language. This method uses the given calendar to construct an appropriate millisecond value for the time if the underlying database does not store timezone information.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support this feature.

Calling this method always throws a SQLException, stating that the function is not supported.

 public Timestamp getTimestamp(int columnIndex) throws SQLException 
{
        return (Timestamp) getColumnInType(columnIndex, Types.TIMESTAMP);
}

Retrieves the value of the designated column in the current row of this ResultSet object as a java.sql.Timestamp object in the Java programming language.

 public Timestamp getTimestamp(String columnName) throws SQLException 
{
        return getTimestamp(findColumn(columnName));
}

Retrieves the value of the designated column in the current row of this ResultSet object as a java.sql.Timestamp object.

 public Timestamp getTimestamp(int columnIndex,
    Calendar cal) throws SQLException 
{
        // ADDED:
        // trace was missing.  not consistent with the other methdods
        // boucherb@users 20020413
        // TODO: implement, based on new jdbcPreparedStatement code
        // and change documentation to reflect
        if (Trace.TRACE) {
            Trace.trace();
        }
        throw getNotSupported();
}

Retrieves the value of the designated column in the current row of this ResultSet object as a java.sql.Timestamp object in the Java programming anguage. This method uses the given calendar to construct an appropriate millisecond value for the timestamp if the underlying database does not store timezone information.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support this feature.

Calling this method always throws a SQLException, stating that the function is not supported.

 public Timestamp getTimestamp(String columnName,
    Calendar cal) throws SQLException 
{
        // MODIFIED:
        // made this consistent with our other column name oriented methods
        // boucherb@users 20020413
        return getTimestamp(findColumn(columnName), cal);
}

Retrieves the value of the designated column in the current row of this ResultSet object as a java.sql.Timestamp object in the Java programming language. This method uses the given calendar to construct an appropriate millisecond value for the timestamp if the underlying database does not store timezone information.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support this feature.

Calling this method always throws a SQLException, stating that the function is not supported.

 public int getType() throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        return rsType;
}

Retrieves the type of this ResultSet object. The type is determined by the Statement object that created the result set.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support and thus never returns ResultSet.TYPE_SCROLL_SENSITIVE

 public URL getURL(int columnIndex) throws SQLException 
{
        throw getNotSupportedJDBC3();
}

Retrieves the value of the designated column in the current row of this ResultSet object as a java.net.URL object in the Java programming language.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support this feature.

Calling this method always throws a SQLException, stating that the function is not supported.

 public URL getURL(String columnName) throws SQLException 
{
        throw getNotSupportedJDBC3();
}

Retrieves the value of the designated column in the current row of this ResultSet object as a java.net.URL object in the Java programming language.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support this feature.

Calling this method always throws a SQLException, stating that the function is not supported.

 public InputStream getUnicodeStream(int columnIndex) throws SQLException 
{
        String s = getString(columnIndex);
        if (s == null) {
            return null;
        }
        return new StringInputStream(s);
}

Retrieves the value of the designated column in the current row of this ResultSet object as as a stream of two-byte Unicode characters. The first byte is the high byte; the second byte is the low byte. The value can then be read in chunks from the stream. This method is particularly suitable for retrieving large LONGVARCHARvalues. The JDBC driver will do any necessary conversion from the database format into Unicode.

Note: All the data in the returned stream must be read prior to getting the value of any other column. The next call to a getter method implicitly closes the stream. Also, a stream may return 0 when the method InputStream.available is called, whether there is data available or not.

HSQLDB-Specific Information:

The limitation noted above does not apply to HSQLDB.

Up to and including 1.6.1, getUnicodeStream (and getAsciiStream) both simply returned a byte stream constructed from the raw getBytes representation. Starting with 1.7.0, this has been corrected to comply with the java.sql specification. When the column is of type CHAR and its variations, it requires no conversion since it is represented internally already as Java Strings. When the column is not of type CHAR and its variations, the returned stream is based on a conversion to the Java String representation of the value. In either case, the obtained stream is always equivalent to a stream of bytes from the value's String representation, with high-byte first.

 public InputStream getUnicodeStream(String columnName) throws SQLException 
{
        return getUnicodeStream(findColumn(columnName));
}

Retrieves the value of the designated column in the current row of this ResultSet object as a stream of two-byte Unicode characters. The first byte is the high byte; the second byte is the low byte. The value can then be read in chunks from the stream. This method is particularly suitable for retrieving large LONGVARCHAR values. The JDBC technology-enabled driver will do any necessary conversion from the database format into Unicode.

Note: All the data in the returned stream must be read prior to getting the value of any other column. The next call to a getter method implicitly closes the stream. Also, a stream may return 0 when the method InputStream.available is called, whether there is data available or not.

 int getUpdateCount() 
{
        return iUpdateCount;
}

If executing my statement updated rows on the database, how many were affected?

 public SQLWarning getWarnings() throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        return null;
}

Retrieves the first warning reported by calls on this ResultSet object. Subsequent warnings on this ResultSet object will be chained to the SQLWarning object that this method returns.

The warning chain is automatically cleared each time a new row is read. This method may not be called on a ResultSet object that has been closed; doing so will cause an SQLException to be thrown.

Note: This warning chain only covers warnings caused by ResultSet methods. Any warning caused by Statement methods (such as reading OUT parameters) will be chained on the Statement object.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not produce SQLWarning objects. This method always returns null.

 public  void insertRow() throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        throw getNotSupported();
}

Inserts the contents of the insert row into this ResultSet object and into the database. The cursor must be on the insert row when this method is called.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

Calling this method always throws a SQLException, stating that the function is not supported.

 public boolean isAfterLast() throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        // At afterLast condition esists when resultset has been traversed and
        // the current row is null.  iCurrentRow should also be set to "0",
        // but no need to test
        if (!bInit) {
            return false;
        }
        return nCurrent == null;
        // why not just: return bInit ? (nCurrent == null) : false; ?
}

Retrieves whether the cursor is after the last row in this ResultSet object.

 public boolean isAutoIncrement(int column) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        // FIXME:
        //
        // We should throw:  this returns false even for columns
        // that *are* autoincrement (identity) columns,
        // which is incorrect behaviour.
        //
        // I realize that it makes no diff. w.r.t. result set updatability,
        // since we do not support updateable results, but that's
        // not the only reason client code wants to know something
        // like this.
        //
        // The (shudder...) alternative is to fix the
        // Result class to provide this info and do a
        // massive sweep of the engine code to ensure
        // the info is set correctly everywhere when
        // generating Result objects.
        // boucherb@users 20025013
        // MISSING:
        // checkColumn(column); ?
        // boucherb@users 20020413
        if (strictMetaData) {
            throw getNotSupported();
        }
        return false;
}

Indicates whether the designated column is automatically numbered, thus read-only.

HSQLDB-Specific Information:

HSQLDB 1.7.1 does not support this feature.

The return value from this method depends on whether the jdbc.strict_md connection property is specified as true. When this property is true: Calling this method always throws a SQLException, stating that the function is not supported.

See discussion at: #getMetaData

 public boolean isBeforeFirst() throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        // Start Old Code
        //      if (bInit == false) {
        //          return true;
        //      }
        //      return false;
        // End Old Code
        // Start New Cose
        // bInit indicates whether the resultset has not been traversed or not
        // true - it has ---- false it hasn't
        return !bInit;
        // End New Cose
}

Retrieves whether the cursor is before the first row in this ResultSet object.

 public boolean isCaseSensitive(int column) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        // MISSING:
        // checkColumn(column); ?
        // boucherb@users 20020413
        if (strictMetaData) {
            throw getNotSupported();
        }
        return true;
}

Indicates whether a column's case matters.

HSQLDB-Specific Information:

HSQLDB 1.7.1 does not support this feature.

The return value from this method depends on whether the jdbc.strict_md connection property is specified as true. When this property is true: Calling this method always throws a SQLException, stating that the function is not supported.

See discussion at: #getMetaData

 public boolean isCurrency(int column) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        checkColumn(column);
        // FIXME:
        // we should throw until this not a todo
        // isCurrency < == > DECIMAL?
        // Re-read the DatabaseMetadata.getTypeInfo spec.
        // boucherb@users 20020413
        // MISSING:
        // boucherb@users 20020413
// fredt@users - 20020413 - DECIMAL has variable scale so it is not currency
        return false;
}

Indicates whether the designated column is a cash value.

HSQLDB-Specific Information:

Up to and including HSQLDB 1.7.0, this method always returns false.

See discussion at: #getMetaData

 public boolean isDefinitelyWritable(int column) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        // FIXME:
        // we should throw until this is not a todo
        // we just don't know as it is: how can we say true?
        // isDefinitelyWritable < == >
        //     isWritable &
        //     ???
        // boucherb@users 20020413
        // MISSING:
        // checkColumn(column); ?
        // boucherb@users 20020413
        // fredt@users - 20020413 - also if the RS column is a DB column
        if (strictMetaData) {
            throw getNotSupported();
        }
        return true;
}

Indicates whether a write on the designated column will definitely succeed.

HSQLDB-Specific Information:

HSQLDB 1.7.1 does not support this feature.

The return value from this method depends on whether the jdbc.strict_md connection property is specified as true. When this property is true: Calling this method always throws a SQLException, stating that the function is not supported.

See discussion at: #getMetaData

 public boolean isFirst() throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        return iCurrentRow == 1;
}

Retrieves whether the cursor is on the first row of this ResultSet object.

 public boolean isLast() throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        // If the resultset has not been traversed, then exit with false
        if ((!bInit) || (nCurrent == null)) {
            return false;
        }
        // At the last row if the next row is null
        return nCurrent.next == null;
}

Retrieves whether the cursor is on the last row of this ResultSet object. Note: Calling the method isLast may be expensive because the JDBC driver might need to fetch ahead one row in order to determine whether the current row is the last row in the result set.

HSQLDB-Specific Information:

Up to and including HSQLDB 1.7.0, this method is not terribly expensive, since the entire result is fetched internally before this object is returned to a caller.

 public int isNullable(int column) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        // FIXME:
        //
        // We should throw:  this returns columnNullable even for columns
        // that are NOT NULL constrained columns,
        // which is incorrect behaviour.
        //
        // I realize that it makes no diff. w.r.t. result set updatability,
        // since we do not support updateable results, but that's
        // not the only reason client code wants to know something
        // like this.
        //
        // The (shudder...) alternative is to fix the
        // Result class to provide this info and do a
        // massive sweep of the engine code to ensure
        // the info is set correctly everywhere when
        // generating Result objects.
        // boucherb@users 20025013
        // MISSING:
        // checkColumn(column); ?
        // boucherb@users 20020413
        if (strictMetaData) {
            return columnNullableUnknown;
        }
        return columnNullable;
}

Indicates the nullability of values in the designated column.

HSQLDB-Specific Information:

The return value from this method depends on whether the jdbc.strict_md connection property is specified as true. When this property is true: Always returns columnNullableUnknown.

See discussion at: #getMetaData

 public boolean isReadOnly(int column) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        // FIXME:
        // we should throw until this is not a todo
        // isReadOnly < == >
        //     db readonly |
        //     connection readonly |
        //     table readonly |
        //     user not granted insert or update or delete on table |
        //     user not granted update on column (not yet supported)
        // boucherb@users 20020413
        // MISSING:
        // checkColumn(column); ?
        // boucherb@users 20020413
        // fredt@users - 20020413 - also if the RS column is a DB column
        if (strictMetaData) {
            throw getNotSupported();
        }
        return false;
}

Indicates whether the designated column is definitely not writable.

HSQLDB-Specific Information:

HSQLDB 1.7.1 does not support this feature.

The return value from this method depends on whether the jdbc.strict_md connection property is specified as true. When this property is true: Calling this method always throws a SQLException, stating that the function is not supported.

See discussion at: #getMetaData

 boolean isResult() 
{
        return rResult == null ? false
                               : true;
}

Does this Result contain actual row data?

Not all results have row data. Some are ERROR results (an execption occured while executing my statement), and some are UPDATE results, in which case updates occured to rows on the database, but no rows were actually returned.

 public boolean isSearchable(int column) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        // CHECKME:
        // is this absolutely always true?
        // javav object (other) columns , for instance,
        // are always equal if not null.
        // Does that qualify as searchable?
        // We need to go back and read the spec. for searchable.
        // boucherb@users 20020413
        // MISSING:
        // checkColumn(column); ?
        // boucherb@users 20020413
// fredt@users - OTHER can be used in a WHERE clause but we don't know if
// RS column is a DB column or a computed value
        if (strictMetaData) {
            throw getNotSupported();
        }
        return true;
}

Indicates whether the designated column can be used in a where clause.

HSQLDB-Specific Information:

HSQLDB 1.7.1 does not support this feature.

The return value from this method depends on whether the jdbc.strict_md connection property is specified as true. When this property is true: Calling this method always throws a SQLException, stating that the function is not supported.

See discussion at: #getMetaData

 public boolean isSigned(int column) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        checkColumn(column);
        int type = rResult.colType[column - 1];
        for (int i = 0; i <  Column.numericTypes.length; i++) {
            if (type == Column.numericTypes[i]) {
                return true;
            }
        }
        return false;
}

Indicates whether values in the designated column are signed numbers.

HSQLDB-Specific Information:

HSQLDB 1.7.1 adds support for this feature.

 public boolean isWritable(int column) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        // FIXME:
        // we should throw until this is not a todo
        // we just don't know as it is: how can we say true?
        // isWritable < == >
        // !isReadOnly &
        // user *is* granted update on table (if column has non-null table)
        // boucherb@users 20020413
        // MISSING:
        // checkColumn(column); ?
        // boucherb@users 20020413
        // fredt@users - 20020413 - also if the RS column is a DB column
        if (strictMetaData) {
            throw getNotSupported();
        }
        return true;
}

Indicates whether it is possible for a write on the designated column to succeed.

HSQLDB-Specific Information:

HSQLDB 1.7.1 does not support this feature.

The return value from this method depends on whether the jdbc.strict_md connection property is specified as true. When this property is true: Calling this method always throws a SQLException, stating that the function is not supported.

See discussion at: #getMetaData

 public boolean last() throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        if (this.getType() == TYPE_FORWARD_ONLY) {
            throw Trace.error(Trace.RESULTSET_FORWARD_ONLY);
        }
        if (rResult == null) {
            return false;
        }
        if (rResult.rRoot == null) {
            return false;
        }
        // it resultset not traversed yet, set to first row
        if ((!bInit) | (nCurrent == null)) {
            first();
        }
        // go to the last row
        while (nCurrent.next != null) {
            iCurrentRow++;
            nCurrent = nCurrent.next;
        }
        return true;
}

Moves the cursor to the last row in this ResultSet object.

 public  void moveToCurrentRow() throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
}

Moves the cursor to the remembered cursor position, usually the current row. This method has no effect if the cursor is not on the insert row.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support #moveToInsertRow() so the current row is never strayed from. Consequentially, this request is simply ignored.

 public  void moveToInsertRow() throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        throw getNotSupported();
}

Moves the cursor to the insert row. The current cursor position is remembered while the cursor is positioned on the insert row. The insert row is a special row associated with an updatable result set. It is essentially a buffer where a new row may be constructed by calling the updater methods prior to inserting the row into the result set. Only the updater, getter, and insertRow methods may be called when the cursor is on the insert row. All of the columns in a result set must be given a value each time this method is called before calling insertRow. An updater method must be called before a getter method can be called on a column value.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

Calling this method always throws a SQLException, stating that the function is not supported.

 public boolean next() throws SQLException 
{
                                                                                                                                         
        bWasNull = false;
        // Have an empty resultset so exit with false
        if (rResult == null) {
            return false;
        }
        if (rResult.rRoot == null) {
            return false;
        }
        if (!bInit) {
            // The resultset has not been traversed, so set the cursor
            // to the first row (1)
            nCurrent    = rResult.rRoot;
            bInit       = true;
            iCurrentRow = 1;
        } else {
            // The resultset has been traversed, if afterLast, retrun false
            if (nCurrent == null) {
                return false;
            }
            // On a valid row so go to next
            nCurrent = nCurrent.next;
            iCurrentRow++;
        }
        // finally test to see if we are in an afterLast situation
        if (nCurrent == null) {
            // Yes, set the current row to 0 and exit with false
            iCurrentRow = 0;
            return false;
        } else {
            // Not afterLast, so success
            return true;
        }
}

Moves the cursor down one row from its current position. A ResultSet cursor is initially positioned before the first row; the first call to the method next makes the first row the current row; the second call makes the second row the current row, and so on.

If an input stream is open for the current row, a call to the method next will implicitly close it. A ResultSet object's warning chain is cleared when a new row is read.

 public boolean previous() throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        if (this.getType() == TYPE_FORWARD_ONLY) {
            throw Trace.error(Trace.RESULTSET_FORWARD_ONLY);
        }
        if (rResult == null) {
            // No resultset
            return false;
        }
        if ((rResult.rRoot == null) || (iCurrentRow == 0)) {
            // Empty resultset or no valid row
            return false;
        }
        if ((bInit) && (nCurrent == null)) {
            // Special condition: in an afterlast condition so go to last
            // row in the resultset
            return last();
        }
        int targetRow = iCurrentRow - 1;
        if (targetRow == 0) {
            // Have gone to a beforeFirst status. Not sure if the
            // beforeFirst status should be set or not.
            // The spec is not very clear.
            beforeFirst();
            return false;
        }
        // Go to the target row.  We always have to start from the first row
        // since the resultset is a forward direction list only
        first();
        while (targetRow != iCurrentRow) {
            nCurrent = nCurrent.next;
            iCurrentRow++;
        }
        return nCurrent != null;
}

Moves the cursor to the previous row in this ResultSet object.

 public  void refreshRow() throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        throw getNotSupported();
}

Refreshes the current row with its most recent value in the database. This method cannot be called when the cursor is on the insert row.

The refreshRow method provides a way for an application to explicitly tell the JDBC driver to refetch a row(s) from the database. An application may want to call refreshRow when caching or prefetching is being done by the JDBC driver to fetch the latest value of a row from the database. The JDBC driver may actually refresh multiple rows at once if the fetch size is greater than one.

All values are refetched subject to the transaction isolation level and cursor sensitivity. If refreshRow is called after calling an updater method, but before calling the method updateRow, then the updates made to the row are lost. Calling the method refreshRow frequently will likely slow performance.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

Calling this method always throws a SQLException, stating that the function is not supported.

 public boolean relative(int rows) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        if (this.getType() == TYPE_FORWARD_ONLY) {
            throw Trace.error(Trace.RESULTSET_FORWARD_ONLY);
        }
        if (rResult == null) {
            return false;
        }
        if ((rResult.rRoot == null) || ((bInit) && (iCurrentRow == 0))) {
            return false;
        }
        // We are on a valid row, so if the direction is from the last row,
        // calculate the target row
        if (rows <  0) {
            rows = iCurrentRow + rows;
            // set status to beforeFirst status
            beforeFirst();
            // Exit if the target row is before the beginning of the resultset
            if (rows < = 0) {
                return false;
            }
        }
        while (rows--  > 0) {
            next();
            if (nCurrent == null) {
                break;
            }
        }
        // if nCurrent is null, the postion will be afterLast
        return nCurrent != null;
}

Moves the cursor a relative number of rows, either positive or negative. Attempting to move beyond the first/last row in the result set positions the cursor before/after the the first/last row. Calling relative(0) is valid, but does not change the cursor position.

Note: Calling the method relative(1) is identical to calling the method next() and calling the method relative(-1) is identical to calling the method previous().

 public boolean rowDeleted() throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        return false;
}

Retrieves whether a row has been deleted. A deleted row may leave a visible "hole" in a result set. This method can be used to detect holes in a result set. The value returned depends on whether or not this ResultSet object can detect deletions.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

This method always returns false.

 public boolean rowInserted() throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        return false;
}

Retrieves whether the current row has had an insertion. The value returned depends on whether or not this ResultSet object can detect visible inserts.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

This method always returns false.

 public boolean rowUpdated() throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        return false;
}

Retrieves whether the current row has been updated. The value returned depends on whether or not the result set can detect updates.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

This method always returns false.

 public  void setFetchDirection(int direction) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace(direction);
        }
        if (rsType == TYPE_FORWARD_ONLY && direction != FETCH_FORWARD) {
            throw getNotSupported();
        }
}

Gives a hint as to the direction in which the rows in this ResultSet object will be processed. The initial value is determined by the Statement object that produced this ResultSet object. The fetch direction may be changed at any time.

HSQLDB-Specific Information:

HSQLDB 1.7.1 builds and returns result sets as a whole, so this method does nothing, apart from the case mandated by the JDBC standard below where an SQLException is thrown with result sets of TYPE_FORWARD_ONLY and fetch directions other than FETCH_FORWARD.

 public  void setFetchSize(int rows) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace(rows);
        }
}

Gives the JDBC driver a hint as to the number of rows that should be fetched from the database when more rows are needed for this ResultSet object. If the fetch size specified is zero, the JDBC driver ignores the value and is free to make its own best guess as to what the fetch size should be. The default value is set by the Statement object that created the result set. The fetch size may be changed at any time.

HSQLDB-Specific Information:

This method does nothing in HSQLDB as the result set is built and returned completely as a whole.

 public  void updateArray(int columnIndex,
    Array x) throws SQLException 
{
        throw getNotSupportedJDBC3();
}

Updates the designated column with a java.sql.Array value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results or this data type.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateArray(String columnName,
    Array x) throws SQLException 
{
        throw getNotSupportedJDBC3();
}

Updates the designated column with a java.sql.Array value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results or this data type.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateAsciiStream(int columnIndex,
    InputStream x,
    int length) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        throw getNotSupported();
}

Updates the designated column with an ascii stream value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateAsciiStream(String columnName,
    InputStream x,
    int length) throws SQLException 
{
        updateAsciiStream(findColumn(columnName), x, length);
}

Updates the designated column with an ascii stream value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateBigDecimal(int columnIndex,
    BigDecimal x) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        throw getNotSupported();
}

Updates the designated column with a java.math.BigDecimal value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateBigDecimal(String columnName,
    BigDecimal x) throws SQLException 
{
        updateBigDecimal(findColumn(columnName), x);
}

Updates the designated column with a java.sql.BigDecimal value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateBinaryStream(int columnIndex,
    InputStream x,
    int length) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        throw getNotSupported();
}

Updates the designated column with a binary stream value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateBinaryStream(String columnName,
    InputStream x,
    int length) throws SQLException 
{
        updateBinaryStream(findColumn(columnName), x, length);
}

Updates the designated column with a binary stream value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateBlob(int columnIndex,
    Blob x) throws SQLException 
{
        throw getNotSupportedJDBC3();
}

Updates the designated column with a java.sql.Blob value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results or this data type.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateBlob(String columnName,
    Blob x) throws SQLException 
{
        throw getNotSupportedJDBC3();
}

Updates the designated column with a java.sql.Blob value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results or this data type.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateBoolean(int columnIndex,
    boolean x) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        throw getNotSupported();
}

Updates the designated column with a boolean value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateBoolean(String columnName,
    boolean x) throws SQLException 
{
        updateBoolean(findColumn(columnName), x);
}

Updates the designated column with a boolean value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateByte(int columnIndex,
    byte x) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        throw getNotSupported();
}

Updates the designated column with a byte value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateByte(String columnName,
    byte x) throws SQLException 
{
        updateByte(findColumn(columnName), x);
}

Updates the designated column with a byte value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateBytes(int columnIndex,
    byte[] x) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        throw getNotSupported();
}

Updates the designated column with a byte array value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateBytes(String columnName,
    byte[] x) throws SQLException 
{
        updateBytes(findColumn(columnName), x);
}

Updates the designated column with a byte array value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateCharacterStream(int columnIndex,
    Reader x,
    int length) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        throw getNotSupported();
}

Updates the designated column with a character stream value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateCharacterStream(String columnName,
    Reader reader,
    int length) throws SQLException 
{
        updateCharacterStream(findColumn(columnName), reader, length);
}

Updates the designated column with a character stream value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateClob(int columnIndex,
    Clob x) throws SQLException 
{
        throw getNotSupportedJDBC3();
}

Updates the designated column with a java.sql.Clob value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results or this data type.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateClob(String columnName,
    Clob x) throws SQLException 
{
        throw getNotSupportedJDBC3();
}

Updates the designated column with a java.sql.Clob value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results or this data type.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateDate(int columnIndex,
    Date x) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        throw getNotSupported();
}

Updates the designated column with a java.sql.Date value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateDate(String columnName,
    Date x) throws SQLException 
{
        updateDate(findColumn(columnName), x);
}

Updates the designated column with a java.sql.Date value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateDouble(int columnIndex,
    double x) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        throw getNotSupported();
}

Updates the designated column with a double value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateDouble(String columnName,
    double x) throws SQLException 
{
        updateDouble(findColumn(columnName), x);
}

Updates the designated column with a double value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateFloat(int columnIndex,
    float x) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        throw getNotSupported();
}

Updates the designated column with a float value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateFloat(String columnName,
    float x) throws SQLException 
{
        updateFloat(findColumn(columnName), x);
}

Updates the designated column with a float value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateInt(int columnIndex,
    int x) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        throw getNotSupported();
}

Updates the designated column with an int value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateInt(String columnName,
    int x) throws SQLException 
{
        updateInt(findColumn(columnName), x);
}

Updates the designated column with an int value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateLong(int columnIndex,
    long x) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        throw getNotSupported();
}

Updates the designated column with a long value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateLong(String columnName,
    long x) throws SQLException 
{
        updateLong(findColumn(columnName), x);
}

Updates the designated column with a long value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateNull(int columnIndex) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace(columnIndex);
        }
        throw getNotSupported();
}

Gives a nullable column a null value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateNull(String columnName) throws SQLException 
{
        updateNull(findColumn(columnName));
}

Updates the designated column with a null value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateObject(int columnIndex,
    Object x) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        throw getNotSupported();
}

Updates the designated column with an Object value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateObject(String columnName,
    Object x) throws SQLException 
{
        updateObject(findColumn(columnName), x);
}

Updates the designated column with an Object value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateObject(int columnIndex,
    Object x,
    int scale) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        throw getNotSupported();
}

Updates the designated column with an Object value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateObject(String columnName,
    Object x,
    int scale) throws SQLException 
{
        updateObject(findColumn(columnName), x, scale);
}

Updates the designated column with an Object value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateRef(int columnIndex,
    Ref x) throws SQLException 
{
        throw getNotSupportedJDBC3();
}

Updates the designated column with a java.sql.Ref value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results or this data type.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateRef(String columnName,
    Ref x) throws SQLException 
{
        throw getNotSupportedJDBC3();
}

Updates the designated column with a java.sql.Ref value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results or this data type.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateRow() throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        throw getNotSupported();
}

Updates the underlying database with the new contents of the current row of this ResultSet object. This method cannot be called when the cursor is on the insert row.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateShort(int columnIndex,
    short x) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        throw getNotSupported();
}

Updates the designated column with a short value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateShort(String columnName,
    short x) throws SQLException 
{
        updateShort(findColumn(columnName), x);
}

Updates the designated column with a short value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateString(int columnIndex,
    String x) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        throw getNotSupported();
}

Updates the designated column with a String value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateString(String columnName,
    String x) throws SQLException 
{
        updateString(findColumn(columnName), x);
}

Updates the designated column with a String value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateTime(int columnIndex,
    Time x) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        throw getNotSupported();
}

Updates the designated column with a java.sql.Time value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateTime(String columnName,
    Time x) throws SQLException 
{
        updateTime(findColumn(columnName), x);
}

Updates the designated column with a java.sql.Time value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateTimestamp(int columnIndex,
    Timestamp x) throws SQLException 
{
        if (Trace.TRACE) {
            Trace.trace();
        }
        throw getNotSupported();
}

Updates the designated column with a java.sql.Timestamp value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

Calling this method always throws a SQLException, stating that the function is not supported.

 public  void updateTimestamp(String columnName,
    Timestamp x) throws SQLException 
{
        updateTimestamp(findColumn(columnName), x);
}

Updates the designated column with a java.sql.Timestamp value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.

HSQLDB-Specific Information:

Up to and including 1.7.1, HSQLDB does not support updateable results.

Calling this method always throws a SQLException, stating that the function is not supported.

 public boolean wasNull() throws SQLException 
{
        return bWasNull;
}

Reports whether the last column read had a value of SQL NULL. Note that you must first call one of the getter methods on a column to try to read its value and then call the method wasNull to see if the value read was SQL NULL.