java/8 : javax/sql/rowset/RowSetMetaDataImpl.java

RowSetMetaDataImpl
https://openjdk.java.net/
GPLv2 + Classpath Exception
/*
 * Copyright (c) 2003, 2014, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package javax.sql.rowset;

import java.sql.*;
import javax.sql.*;
import java.io.*;

import java.lang.reflect.*;

Provides implementations for the methods that set and get
metadata information about a RowSet object's columns.
A RowSetMetaDataImpl object keeps track of the
number of columns in the rowset and maintains an internal array
of column attributes for each column.

A RowSet object creates a RowSetMetaDataImpl
object internally in order to set and retrieve information about
its columns.

NOTE: All metadata in a RowSetMetaDataImpl object
should be considered as unavailable until the RowSet object
that it describes is populated.
Therefore, any RowSetMetaDataImpl method that retrieves information
is defined as having unspecified behavior when it is called
before the RowSet object contains data.
Since: 1.5/**
 * Provides implementations for the methods that set and get
 * metadata information about a <code>RowSet</code> object's columns.
 * A <code>RowSetMetaDataImpl</code> object keeps track of the
 * number of columns in the rowset and maintains an internal array
 * of column attributes for each column.
 * <P>
 * A <code>RowSet</code> object creates a <code>RowSetMetaDataImpl</code>
 * object internally in order to set and retrieve information about
 * its columns.
 * <P>
 * NOTE: All metadata in a <code>RowSetMetaDataImpl</code> object
 * should be considered as unavailable until the <code>RowSet</code> object
 * that it describes is populated.
 * Therefore, any <code>RowSetMetaDataImpl</code> method that retrieves information
 * is defined as having unspecified behavior when it is called
 * before the <code>RowSet</code> object contains data.
 *
 * @since 1.5
 */
public class RowSetMetaDataImpl implements RowSetMetaData,  Serializable {

    The number of columns in the RowSet object that created
this RowSetMetaDataImpl object.
@serial /**
     * The number of columns in the <code>RowSet</code> object that created
     * this <code>RowSetMetaDataImpl</code> object.
     * @serial
     */
    private int colCount;

    An array of ColInfo objects used to store information
about each column in the RowSet object for which
this RowSetMetaDataImpl object was created. The first
ColInfo object in this array contains information about
the first column in the RowSet object, the second element
contains information about the second column, and so on.
@serial /**
     * An array of <code>ColInfo</code> objects used to store information
     * about each column in the <code>RowSet</code> object for which
     * this <code>RowSetMetaDataImpl</code> object was created. The first
     * <code>ColInfo</code> object in this array contains information about
     * the first column in the <code>RowSet</code> object, the second element
     * contains information about the second column, and so on.
     * @serial
     */
    private ColInfo[] colInfo;

    Checks to see that the designated column is a valid column number for
the RowSet object for which this RowSetMetaDataImpl
was created. To be valid, a column number must be greater than
0 and less than or equal to the number of columns in a row.
Throws:  SQLException with the message "Invalid column index"
 –       if the given column number is out of the range of valid column
       numbers for the RowSet object/**
     * Checks to see that the designated column is a valid column number for
     * the <code>RowSet</code> object for which this <code>RowSetMetaDataImpl</code>
     * was created. To be valid, a column number must be greater than
     * <code>0</code> and less than or equal to the number of columns in a row.
     * @throws <code>SQLException</code> with the message "Invalid column index"
     *        if the given column number is out of the range of valid column
     *        numbers for the <code>RowSet</code> object
     */
    private void checkColRange(int col) throws SQLException {
        if (col <= 0 || col > colCount) {
            throw new SQLException("Invalid column index :"+col);
        }
    }

    Checks to see that the given SQL type is a valid column type and throws an
SQLException object if it is not.
To be valid, a SQL type must be one of the constant values
in the java.sql.Types
class.
Params: SQLType – an int defined in the class java.sql.Types
Throws: SQLException – if the given int is not a constant defined in the
        class java.sql.Types/**
     * Checks to see that the given SQL type is a valid column type and throws an
     * <code>SQLException</code> object if it is not.
     * To be valid, a SQL type must be one of the constant values
     * in the <code><a href="../../sql/Types.html">java.sql.Types</a></code>
     * class.
     *
     * @param SQLType an <code>int</code> defined in the class <code>java.sql.Types</code>
     * @throws SQLException if the given <code>int</code> is not a constant defined in the
     *         class <code>java.sql.Types</code>
     */
    private void checkColType(int SQLType) throws SQLException {
        try {
            Class<?> c = java.sql.Types.class;
            Field[] publicFields = c.getFields();
            int fieldValue = 0;
            for (int i = 0; i < publicFields.length; i++) {
                fieldValue = publicFields[i].getInt(c);
                if (fieldValue == SQLType) {
                    return;
                 }
            }
        } catch (Exception e) {
            throw new SQLException(e.getMessage());
        }
        throw new SQLException("Invalid SQL type for column");
    }

    Sets to the given number the number of columns in the RowSet
object for which this RowSetMetaDataImpl object was created.
Params: columnCount – an int giving the number of columns in the
       RowSet object
Throws: SQLException – if the given number is equal to or less than zero/**
     * Sets to the given number the number of columns in the <code>RowSet</code>
     * object for which this <code>RowSetMetaDataImpl</code> object was created.
     *
     * @param columnCount an <code>int</code> giving the number of columns in the
     *        <code>RowSet</code> object
     * @throws SQLException if the given number is equal to or less than zero
     */
    public void setColumnCount(int columnCount) throws SQLException {

        if (columnCount <= 0) {
            throw new SQLException("Invalid column count. Cannot be less " +
                "or equal to zero");
            }

       colCount = columnCount;

       // If the colCount is Integer.MAX_VALUE,
       // we do not initialize the colInfo object.
       // even if we try to initialize the colCount with
       // colCount = Integer.MAx_VALUE-1, the colInfo
       // initialization fails throwing an ERROR
       // OutOfMemory Exception. So we do not initialize
       // colInfo at Integer.MAX_VALUE. This is to pass TCK.

       if(!(colCount == Integer.MAX_VALUE)) {
            colInfo = new ColInfo[colCount + 1];

           for (int i=1; i <= colCount; i++) {
                 colInfo[i] = new ColInfo();
           }
       }


    }

    Sets whether the designated column is automatically
numbered, thus read-only, to the given boolean
value.
Params: columnIndex – the first column is 1, the second is 2, and so on;
       must be between 1 and the number of columns
       in the rowset, inclusive
property – true if the given column is
                automatically incremented; false
                otherwise
Throws: SQLException – if a database access error occurs or
        the given index is out of bounds/**
     * Sets whether the designated column is automatically
     * numbered, thus read-only, to the given <code>boolean</code>
     * value.
     *
     * @param columnIndex the first column is 1, the second is 2, and so on;
     *        must be between <code>1</code> and the number of columns
     *        in the rowset, inclusive
     * @param property <code>true</code> if the given column is
     *                 automatically incremented; <code>false</code>
     *                 otherwise
     * @throws SQLException if a database access error occurs or
     *         the given index is out of bounds
     */
    public void setAutoIncrement(int columnIndex, boolean property) throws SQLException {
        checkColRange(columnIndex);
        colInfo[columnIndex].autoIncrement = property;
    }

    Sets whether the name of the designated column is case sensitive to
the given boolean.
Params: columnIndex – the first column is 1, the second is 2, and so on;
       must be between 1 and the number of columns
       in the rowset, inclusive
property – true to indicate that the column
                name is case sensitive; false otherwise
Throws: SQLException – if a database access error occurs or
        the given column number is out of bounds/**
     * Sets whether the name of the designated column is case sensitive to
     * the given <code>boolean</code>.
     *
     * @param columnIndex the first column is 1, the second is 2, and so on;
     *        must be between <code>1</code> and the number of columns
     *        in the rowset, inclusive
     * @param property <code>true</code> to indicate that the column
     *                 name is case sensitive; <code>false</code> otherwise
     * @throws SQLException if a database access error occurs or
     *         the given column number is out of bounds
     */
    public void setCaseSensitive(int columnIndex, boolean property) throws SQLException {
        checkColRange(columnIndex);
        colInfo[columnIndex].caseSensitive = property;
    }

    Sets whether a value stored in the designated column can be used
in a WHERE clause to the given boolean value.
Params: columnIndex – the first column is 1, the second is 2, and so on;
                   must be between 1 and the number
                   of columns in the rowset, inclusive
property – true to indicate that a column
                value can be used in a WHERE clause;
                false otherwise
Throws: SQLException – if a database access error occurs or
        the given column number is out of bounds/**
     * Sets whether a value stored in the designated column can be used
     * in a <code>WHERE</code> clause to the given <code>boolean</code> value.
     *
     * @param columnIndex the first column is 1, the second is 2, and so on;
     *                    must be between <code>1</code> and the number
     *                    of columns in the rowset, inclusive
     * @param property <code>true</code> to indicate that a column
     *                 value can be used in a <code>WHERE</code> clause;
     *                 <code>false</code> otherwise
     *
     * @throws SQLException if a database access error occurs or
     *         the given column number is out of bounds
     */
    public void setSearchable(int columnIndex, boolean property)
        throws SQLException {
        checkColRange(columnIndex);
        colInfo[columnIndex].searchable = property;
    }

    Sets whether a value stored in the designated column is a cash
value to the given boolean.
Params: columnIndex – the first column is 1, the second is 2, and so on;
must be between 1 and the number of columns,
inclusive between 1 and the number of columns, inclusive
property – true if the value is a cash value; false otherwise.
Throws: SQLException – if a database access error occurs
        or the given column number is out of bounds/**
     * Sets whether a value stored in the designated column is a cash
     * value to the given <code>boolean</code>.
     *
     * @param columnIndex the first column is 1, the second is 2, and so on;
     * must be between <code>1</code> and the number of columns,
     * inclusive between <code>1</code> and the number of columns, inclusive
     * @param property true if the value is a cash value; false otherwise.
     * @throws SQLException if a database access error occurs
     *         or the given column number is out of bounds
     */
    public void setCurrency(int columnIndex, boolean property)
        throws SQLException {
        checkColRange(columnIndex);
        colInfo[columnIndex].currency = property;
    }

    Sets whether a value stored in the designated column can be set
to NULL to the given constant from the interface
ResultSetMetaData.
Params: columnIndex – the first column is 1, the second is 2, and so on;
       must be between 1 and the number of columns, inclusive
property – one of the following ResultSetMetaData constants:
                columnNoNulls,
                columnNullable, or
                columnNullableUnknown
Throws: SQLException – if a database access error occurs,
        the given column number is out of bounds, or the value supplied
        for the property parameter is not one of the following
        constants:
          ResultSetMetaData.columnNoNulls,
          ResultSetMetaData.columnNullable, or
          ResultSetMetaData.columnNullableUnknown/**
     * Sets whether a value stored in the designated column can be set
     * to <code>NULL</code> to the given constant from the interface
     * <code>ResultSetMetaData</code>.
     *
     * @param columnIndex the first column is 1, the second is 2, and so on;
     *        must be between <code>1</code> and the number of columns, inclusive
     * @param property one of the following <code>ResultSetMetaData</code> constants:
     *                 <code>columnNoNulls</code>,
     *                 <code>columnNullable</code>, or
     *                 <code>columnNullableUnknown</code>
     *
     * @throws SQLException if a database access error occurs,
     *         the given column number is out of bounds, or the value supplied
     *         for the <i>property</i> parameter is not one of the following
     *         constants:
     *           <code>ResultSetMetaData.columnNoNulls</code>,
     *           <code>ResultSetMetaData.columnNullable</code>, or
     *           <code>ResultSetMetaData.columnNullableUnknown</code>
     */
    public void setNullable(int columnIndex, int property) throws SQLException {
        if ((property < ResultSetMetaData.columnNoNulls) ||
            property > ResultSetMetaData.columnNullableUnknown) {
                throw new SQLException("Invalid nullable constant set. Must be " +
                    "either columnNoNulls, columnNullable or columnNullableUnknown");
        }
        checkColRange(columnIndex);
        colInfo[columnIndex].nullable = property;
    }

    Sets whether a value stored in the designated column is a signed
number to the given boolean.
Params: columnIndex – the first column is 1, the second is 2, and so on;
       must be between 1 and the number of columns, inclusive
property – true to indicate that a column
                value is a signed number;
                false to indicate that it is not
Throws: SQLException – if a database access error occurs
        or the given column number is out of bounds/**
     * Sets whether a value stored in the designated column is a signed
     * number to the given <code>boolean</code>.
     *
     * @param columnIndex the first column is 1, the second is 2, and so on;
     *        must be between <code>1</code> and the number of columns, inclusive
     * @param property <code>true</code> to indicate that a column
     *                 value is a signed number;
     *                 <code>false</code> to indicate that it is not
     * @throws SQLException if a database access error occurs
     *         or the given column number is out of bounds
     */
    public void setSigned(int columnIndex, boolean property) throws SQLException {
        checkColRange(columnIndex);
        colInfo[columnIndex].signed = property;
    }

    Sets the normal maximum number of chars in the designated column
to the given number.
Params: columnIndex – the first column is 1, the second is 2, and so on;
       must be between 1 and the number of columns, inclusive
size – the maximum size of the column in chars; must be
       0 or more
Throws: SQLException – if a database access error occurs,
       the given column number is out of bounds, or size is
       less than 0/**
     * Sets the normal maximum number of chars in the designated column
     * to the given number.
     *
     * @param columnIndex the first column is 1, the second is 2, and so on;
     *        must be between <code>1</code> and the number of columns, inclusive
     * @param size the maximum size of the column in chars; must be
     *        <code>0</code> or more
     * @throws SQLException if a database access error occurs,
     *        the given column number is out of bounds, or <i>size</i> is
     *        less than <code>0</code>
     */
    public void setColumnDisplaySize(int columnIndex, int size) throws SQLException {
        if (size < 0) {
            throw new SQLException("Invalid column display size. Cannot be less " +
                "than zero");
        }
        checkColRange(columnIndex);
        colInfo[columnIndex].columnDisplaySize = size;
    }

    Sets the suggested column label for use in printouts and
displays, if any, to label. If label is
null, the column label is set to an empty string
("").
Params: columnIndex – the first column is 1, the second is 2, and so on;
       must be between 1 and the number of columns, inclusive
label – the column label to be used in printouts and displays; if the
       column label is null, an empty String is
       set
Throws: SQLException – if a database access error occurs
        or the given column index is out of bounds/**
     * Sets the suggested column label for use in printouts and
     * displays, if any, to <i>label</i>. If <i>label</i> is
     * <code>null</code>, the column label is set to an empty string
     * ("").
     *
     * @param columnIndex the first column is 1, the second is 2, and so on;
     *        must be between <code>1</code> and the number of columns, inclusive
     * @param label the column label to be used in printouts and displays; if the
     *        column label is <code>null</code>, an empty <code>String</code> is
     *        set
     * @throws SQLException if a database access error occurs
     *         or the given column index is out of bounds
     */
    public void setColumnLabel(int columnIndex, String label) throws SQLException {
        checkColRange(columnIndex);
        if (label != null) {
            colInfo[columnIndex].columnLabel = label;
        } else {
            colInfo[columnIndex].columnLabel = "";
        }
    }

    Sets the column name of the designated column to the given name.
Params: columnIndex – the first column is 1, the second is 2, and so on;
     must be between 1 and the number of columns, inclusive
columnName – a String object indicating the column name;
     if the given name is null, an empty String
     is set
Throws: SQLException – if a database access error occurs or the given column
     index is out of bounds/**
     * Sets the column name of the designated column to the given name.
     *
     * @param columnIndex the first column is 1, the second is 2, and so on;
     *      must be between <code>1</code> and the number of columns, inclusive
     * @param columnName a <code>String</code> object indicating the column name;
     *      if the given name is <code>null</code>, an empty <code>String</code>
     *      is set
     * @throws SQLException if a database access error occurs or the given column
     *      index is out of bounds
     */
    public void setColumnName(int columnIndex, String columnName) throws SQLException {
        checkColRange(columnIndex);
        if (columnName != null) {
            colInfo[columnIndex].columnName = columnName;
        } else {
            colInfo[columnIndex].columnName = "";
        }
    }

    Sets the designated column's table's schema name, if any, to
schemaName. If schemaName is null,
the schema name is set to an empty string ("").
Params: columnIndex – the first column is 1, the second is 2, and so on;
       must be between 1 and the number of columns, inclusive
schemaName – the schema name for the table from which a value in the
       designated column was derived; may be an empty String
       or null
Throws: SQLException – if a database access error occurs
       or the given column number is out of bounds/**
     * Sets the designated column's table's schema name, if any, to
     * <i>schemaName</i>. If <i>schemaName</i> is <code>null</code>,
     * the schema name is set to an empty string ("").
     *
     * @param columnIndex the first column is 1, the second is 2, and so on;
     *        must be between <code>1</code> and the number of columns, inclusive
     * @param schemaName the schema name for the table from which a value in the
     *        designated column was derived; may be an empty <code>String</code>
     *        or <code>null</code>
     * @throws SQLException if a database access error occurs
     *        or the given column number is out of bounds
     */
    public void setSchemaName(int columnIndex, String schemaName) throws SQLException {
        checkColRange(columnIndex);
        if (schemaName != null ) {
            colInfo[columnIndex].schemaName = schemaName;
        } else {
            colInfo[columnIndex].schemaName = "";
        }
    }

    Sets the total number of decimal digits in a value stored in the
designated column to the given number.
Params: columnIndex – the first column is 1, the second is 2, and so on;
       must be between 1 and the number of columns, inclusive
precision – the total number of decimal digits; must be 0
       or more
Throws: SQLException – if a database access error occurs,
        columnIndex is out of bounds, or precision
        is less than 0/**
     * Sets the total number of decimal digits in a value stored in the
     * designated column to the given number.
     *
     * @param columnIndex the first column is 1, the second is 2, and so on;
     *        must be between <code>1</code> and the number of columns, inclusive
     * @param precision the total number of decimal digits; must be <code>0</code>
     *        or more
     * @throws SQLException if a database access error occurs,
     *         <i>columnIndex</i> is out of bounds, or <i>precision</i>
     *         is less than <code>0</code>
     */
    public void setPrecision(int columnIndex, int precision) throws SQLException {

        if (precision < 0) {
            throw new SQLException("Invalid precision value. Cannot be less " +
                "than zero");
        }
        checkColRange(columnIndex);
        colInfo[columnIndex].colPrecision = precision;
    }

    Sets the number of digits to the right of the decimal point in a value
stored in the designated column to the given number.
Params: columnIndex – the first column is 1, the second is 2, and so on;
       must be between 1 and the number of columns, inclusive
scale – the number of digits to the right of the decimal point; must be
       zero or greater
Throws: SQLException – if a database access error occurs,
        columnIndex is out of bounds, or scale
        is less than 0/**
     * Sets the number of digits to the right of the decimal point in a value
     * stored in the designated column to the given number.
     *
     * @param columnIndex the first column is 1, the second is 2, and so on;
     *        must be between <code>1</code> and the number of columns, inclusive
     * @param scale the number of digits to the right of the decimal point; must be
     *        zero or greater
     * @throws SQLException if a database access error occurs,
     *         <i>columnIndex</i> is out of bounds, or <i>scale</i>
     *         is less than <code>0</code>
     */
    public void setScale(int columnIndex, int scale) throws SQLException {
        if (scale < 0) {
            throw new SQLException("Invalid scale size. Cannot be less " +
                "than zero");
        }
        checkColRange(columnIndex);
        colInfo[columnIndex].colScale = scale;
    }

    Sets the name of the table from which the designated column
was derived to the given table name.
Params: columnIndex – the first column is 1, the second is 2, and so on;
       must be between 1 and the number of columns, inclusive
tableName – the column's table name; may be null or an
       empty string
Throws: SQLException – if a database access error occurs
        or the given column number is out of bounds/**
     * Sets the name of the table from which the designated column
     * was derived to the given table name.
     *
     * @param columnIndex the first column is 1, the second is 2, and so on;
     *        must be between <code>1</code> and the number of columns, inclusive
     * @param tableName the column's table name; may be <code>null</code> or an
     *        empty string
     * @throws SQLException if a database access error occurs
     *         or the given column number is out of bounds
     */
    public void setTableName(int columnIndex, String tableName) throws SQLException {
        checkColRange(columnIndex);
        if (tableName != null) {
            colInfo[columnIndex].tableName = tableName;
        } else {
            colInfo[columnIndex].tableName = "";
        }
    }

    Sets the catalog name of the table from which the designated
column was derived to catalogName. If catalogName
is null, the catalog name is set to an empty string.
Params: columnIndex – the first column is 1, the second is 2, and so on;
       must be between 1 and the number of columns, inclusive
catalogName – the column's table's catalog name; if the catalogName
       is null, an empty String is set
Throws: SQLException – if a database access error occurs
        or the given column number is out of bounds/**
     * Sets the catalog name of the table from which the designated
     * column was derived to <i>catalogName</i>. If <i>catalogName</i>
     * is <code>null</code>, the catalog name is set to an empty string.
     *
     * @param columnIndex the first column is 1, the second is 2, and so on;
     *        must be between <code>1</code> and the number of columns, inclusive
     * @param catalogName the column's table's catalog name; if the catalogName
     *        is <code>null</code>, an empty <code>String</code> is set
     * @throws SQLException if a database access error occurs
     *         or the given column number is out of bounds
     */
    public void setCatalogName(int columnIndex, String catalogName) throws SQLException {
        checkColRange(columnIndex);
        if (catalogName != null)
            colInfo[columnIndex].catName = catalogName;
        else
            colInfo[columnIndex].catName = "";
    }

    Sets the SQL type code for values stored in the designated column
to the given type code from the class java.sql.Types.
Params: columnIndex – the first column is 1, the second is 2, and so on;
       must be between 1 and the number of columns, inclusive
SQLType – the designated column's SQL type, which must be one of the
               constants in the class java.sql.Types
Throws: SQLException – if a database access error occurs,
        the given column number is out of bounds, or the column type
        specified is not one of the constants in
        java.sql.Types
See Also: Types/**
     * Sets the SQL type code for values stored in the designated column
     * to the given type code from the class <code>java.sql.Types</code>.
     *
     * @param columnIndex the first column is 1, the second is 2, and so on;
     *        must be between <code>1</code> and the number of columns, inclusive
     * @param SQLType the designated column's SQL type, which must be one of the
     *                constants in the class <code>java.sql.Types</code>
     * @throws SQLException if a database access error occurs,
     *         the given column number is out of bounds, or the column type
     *         specified is not one of the constants in
     *         <code>java.sql.Types</code>
     * @see java.sql.Types
     */
    public void setColumnType(int columnIndex, int SQLType) throws SQLException {
        // examine java.sql.Type reflectively, loop on the fields and check
        // this. Separate out into a private method
        checkColType(SQLType);
        checkColRange(columnIndex);
        colInfo[columnIndex].colType = SQLType;
    }

    Sets the type name used by the data source for values stored in the
designated column to the given type name.
Params: columnIndex – the first column is 1, the second is 2, and so on;
must be between 1 and the number of columns, inclusive
typeName – the data source-specific type name; if typeName is
       null, an empty String is set
Throws: SQLException – if a database access error occurs
        or the given column number is out of bounds/**
     * Sets the type name used by the data source for values stored in the
     * designated column to the given type name.
     *
     * @param columnIndex the first column is 1, the second is 2, and so on;
     * must be between <code>1</code> and the number of columns, inclusive
     * @param typeName the data source-specific type name; if <i>typeName</i> is
     *        <code>null</code>, an empty <code>String</code> is set
     * @throws SQLException if a database access error occurs
     *         or the given column number is out of bounds
     */
    public void setColumnTypeName(int columnIndex, String typeName)
        throws SQLException {
        checkColRange(columnIndex);
        if (typeName != null) {
            colInfo[columnIndex].colTypeName = typeName;
        } else {
            colInfo[columnIndex].colTypeName = "";
        }
    }

    Retrieves the number of columns in the RowSet object
for which this RowSetMetaDataImpl object was created.
Throws: SQLException – if an error occurs determining the column count
Returns: the number of columns/**
     * Retrieves the number of columns in the <code>RowSet</code> object
     * for which this <code>RowSetMetaDataImpl</code> object was created.
     *
     * @return the number of columns
     * @throws SQLException if an error occurs determining the column count
     */
    public int getColumnCount() throws SQLException {
        return colCount;
    }

    Retrieves whether a value stored in the designated column is
automatically numbered, and thus readonly.
Params: columnIndex – the first column is 1, the second is 2, and so on;
        must be between 1 and the number of columns, inclusive
Throws: SQLException – if a database access error occurs
or the given column number is out of bounds
Returns: true if the column is automatically numbered;
        false otherwise/**
     * Retrieves whether a value stored in the designated column is
     * automatically numbered, and thus readonly.
     *
     * @param columnIndex the first column is 1, the second is 2, and so on;
     *         must be between <code>1</code> and the number of columns, inclusive
     * @return <code>true</code> if the column is automatically numbered;
     *         <code>false</code> otherwise
     * @throws SQLException if a database access error occurs
     * or the given column number is out of bounds
     */
    public boolean isAutoIncrement(int columnIndex) throws SQLException {
        checkColRange(columnIndex);
        return colInfo[columnIndex].autoIncrement;
    }

    Indicates whether the case of the designated column's name
matters.
Params: columnIndex – the first column is 1, the second is 2, and so on;
must be between 1 and the number of columns, inclusive
Throws: SQLException – if a database access error occurs
or the given column number is out of bounds
Returns: true if the column name is case sensitive;
         false otherwise/**
     * Indicates whether the case of the designated column's name
     * matters.
     *
     * @param columnIndex the first column is 1, the second is 2, and so on;
     * must be between <code>1</code> and the number of columns, inclusive
     * @return <code>true</code> if the column name is case sensitive;
     *          <code>false</code> otherwise
     * @throws SQLException if a database access error occurs
     * or the given column number is out of bounds
     */
    public boolean isCaseSensitive(int columnIndex) throws SQLException {
        checkColRange(columnIndex);
        return colInfo[columnIndex].caseSensitive;
    }

    Indicates whether a value stored in the designated column
can be used in a WHERE clause.
Params: columnIndex – the first column is 1, the second is 2, and so on;
       must be between 1 and the number of columns, inclusive
Throws: SQLException – if a database access error occurs
        or the given column number is out of bounds
Returns: true if a value in the designated column can be used in a
        WHERE clause; false otherwise/**
     * Indicates whether a value stored in the designated column
     * can be used in a <code>WHERE</code> clause.
     *
     * @param columnIndex the first column is 1, the second is 2, and so on;
     *        must be between <code>1</code> and the number of columns, inclusive
     * @return <code>true</code> if a value in the designated column can be used in a
     *         <code>WHERE</code> clause; <code>false</code> otherwise
     * @throws SQLException if a database access error occurs
     *         or the given column number is out of bounds
     */
    public boolean isSearchable(int columnIndex) throws SQLException {
        checkColRange(columnIndex);
        return colInfo[columnIndex].searchable;
    }

    Indicates whether a value stored in the designated column
is a cash value.
Params: columnIndex – the first column is 1, the second is 2, and so on;
       must be between 1 and the number of columns, inclusive
Throws: SQLException – if a database access error occurs
        or the given column number is out of bounds
Returns: true if a value in the designated column is a cash value;
        false otherwise/**
     * Indicates whether a value stored in the designated column
     * is a cash value.
     *
     * @param columnIndex the first column is 1, the second is 2, and so on;
     *        must be between <code>1</code> and the number of columns, inclusive
     * @return <code>true</code> if a value in the designated column is a cash value;
     *         <code>false</code> otherwise
     * @throws SQLException if a database access error occurs
     *         or the given column number is out of bounds
     */
    public boolean isCurrency(int columnIndex) throws SQLException {
        checkColRange(columnIndex);
        return colInfo[columnIndex].currency;
    }

    Retrieves a constant indicating whether it is possible
to store a NULL value in the designated column.
Params: columnIndex – the first column is 1, the second is 2, and so on;
       must be between 1 and the number of columns, inclusive
Throws: SQLException – if a database access error occurs
        or the given column number is out of bounds
Returns: a constant from the ResultSetMetaData interface;
        either columnNoNulls,
        columnNullable, or
        columnNullableUnknown/**
     * Retrieves a constant indicating whether it is possible
     * to store a <code>NULL</code> value in the designated column.
     *
     * @param columnIndex the first column is 1, the second is 2, and so on;
     *        must be between <code>1</code> and the number of columns, inclusive
     * @return a constant from the <code>ResultSetMetaData</code> interface;
     *         either <code>columnNoNulls</code>,
     *         <code>columnNullable</code>, or
     *         <code>columnNullableUnknown</code>
     * @throws SQLException if a database access error occurs
     *         or the given column number is out of bounds
     */
    public int isNullable(int columnIndex) throws SQLException {
        checkColRange(columnIndex);
        return colInfo[columnIndex].nullable;
    }

    Indicates whether a value stored in the designated column is
a signed number.
Params: columnIndex – the first column is 1, the second is 2, and so on;
       must be between 1 and the number of columns, inclusive
Throws: SQLException – if a database access error occurs
        or the given column number is out of bounds
Returns: true if a value in the designated column is a signed
        number; false otherwise/**
     * Indicates whether a value stored in the designated column is
     * a signed number.
     *
     * @param columnIndex the first column is 1, the second is 2, and so on;
     *        must be between <code>1</code> and the number of columns, inclusive
     * @return <code>true</code> if a value in the designated column is a signed
     *         number; <code>false</code> otherwise
     * @throws SQLException if a database access error occurs
     *         or the given column number is out of bounds
     */
    public boolean isSigned(int columnIndex) throws SQLException {
        checkColRange(columnIndex);
        return colInfo[columnIndex].signed;
    }

    Retrieves the normal maximum width in chars of the designated column.
Params: columnIndex – the first column is 1, the second is 2, and so on;
       must be between 1 and the number of columns, inclusive
Throws: SQLException – if a database access error occurs
        or the given column number is out of bounds
Returns: the maximum number of chars that can be displayed in the designated
        column/**
     * Retrieves the normal maximum width in chars of the designated column.
     *
     * @param columnIndex the first column is 1, the second is 2, and so on;
     *        must be between <code>1</code> and the number of columns, inclusive
     * @return the maximum number of chars that can be displayed in the designated
     *         column
     * @throws SQLException if a database access error occurs
     *         or the given column number is out of bounds
     */
    public int getColumnDisplaySize(int columnIndex) throws SQLException {
        checkColRange(columnIndex);
        return colInfo[columnIndex].columnDisplaySize;
    }

    Retrieves the suggested column title for the designated
column for use in printouts and displays.
Params: columnIndex – the first column is 1, the second is 2, and so on;
       must be between 1 and the number of columns, inclusive
Throws: SQLException – if a database access error occurs
        or the given column number is out of bounds
Returns: the suggested column name to use in printouts and displays/**
     * Retrieves the suggested column title for the designated
     * column for use in printouts and displays.
     *
     * @param columnIndex the first column is 1, the second is 2, and so on;
     *        must be between <code>1</code> and the number of columns, inclusive
     * @return the suggested column name to use in printouts and displays
     * @throws SQLException if a database access error occurs
     *         or the given column number is out of bounds
     */
    public String getColumnLabel(int columnIndex) throws SQLException {
        checkColRange(columnIndex);
        return colInfo[columnIndex].columnLabel;
    }

    Retrieves the name of the designated column.
Params: columnIndex – the first column is 1, the second is 2, and so on;
must be between 1 and the number of columns, inclusive
Throws: SQLException – if a database access error occurs
or the given column number is out of bounds
Returns: the column name of the designated column/**
     * Retrieves the name of the designated column.
     *
     * @param columnIndex the first column is 1, the second is 2, and so on;
     * must be between <code>1</code> and the number of columns, inclusive
     * @return the column name of the designated column
     * @throws SQLException if a database access error occurs
     * or the given column number is out of bounds
     */
    public String getColumnName(int columnIndex) throws SQLException {
        checkColRange(columnIndex);
        return colInfo[columnIndex].columnName;
    }

    Retrieves the schema name of the table from which the value
in the designated column was derived.
Params: columnIndex – the first column is 1, the second is 2, and so on;
        must be between 1 and the number of columns,
        inclusive
Throws: SQLException – if a database access error occurs
or the given column number is out of bounds
Returns: the schema name or an empty String if no schema
        name is available/**
     * Retrieves the schema name of the table from which the value
     * in the designated column was derived.
     *
     * @param columnIndex the first column is 1, the second is 2, and so on;
     *         must be between <code>1</code> and the number of columns,
     *         inclusive
     * @return the schema name or an empty <code>String</code> if no schema
     *         name is available
     * @throws SQLException if a database access error occurs
     * or the given column number is out of bounds
     */
    public String getSchemaName(int columnIndex) throws SQLException {
        checkColRange(columnIndex);
        String str ="";
        if(colInfo[columnIndex].schemaName == null){
        } else {
              str = colInfo[columnIndex].schemaName;
        }
        return str;
    }

    Retrieves the total number of digits for values stored in
the designated column.
Params: columnIndex – the first column is 1, the second is 2, and so on;
must be between 1 and the number of columns, inclusive
Throws: SQLException – if a database access error occurs
or the given column number is out of bounds
Returns: the precision for values stored in the designated column/**
     * Retrieves the total number of digits for values stored in
     * the designated column.
     *
     * @param columnIndex the first column is 1, the second is 2, and so on;
     * must be between <code>1</code> and the number of columns, inclusive
     * @return the precision for values stored in the designated column
     * @throws SQLException if a database access error occurs
     * or the given column number is out of bounds
     */
    public int getPrecision(int columnIndex) throws SQLException {
        checkColRange(columnIndex);
        return colInfo[columnIndex].colPrecision;
    }

    Retrieves the number of digits to the right of the decimal point
for values stored in the designated column.
Params: columnIndex – the first column is 1, the second is 2, and so on;
must be between 1 and the number of columns, inclusive
Throws: SQLException – if a database access error occurs
or the given column number is out of bounds
Returns: the scale for values stored in the designated column/**
     * Retrieves the number of digits to the right of the decimal point
     * for values stored in the designated column.
     *
     * @param columnIndex the first column is 1, the second is 2, and so on;
     * must be between <code>1</code> and the number of columns, inclusive
     * @return the scale for values stored in the designated column
     * @throws SQLException if a database access error occurs
     * or the given column number is out of bounds
     */
    public int getScale(int columnIndex) throws SQLException {
        checkColRange(columnIndex);
        return colInfo[columnIndex].colScale;
    }

    Retrieves the name of the table from which the value
in the designated column was derived.
Params: columnIndex – the first column is 1, the second is 2, and so on;
must be between 1 and the number of columns, inclusive
Throws: SQLException – if a database access error occurs
or the given column number is out of bounds
Returns: the table name or an empty String if no table name
        is available/**
     * Retrieves the name of the table from which the value
     * in the designated column was derived.
     *
     * @param columnIndex the first column is 1, the second is 2, and so on;
     * must be between <code>1</code> and the number of columns, inclusive
     * @return the table name or an empty <code>String</code> if no table name
     *         is available
     * @throws SQLException if a database access error occurs
     * or the given column number is out of bounds
     */
    public String getTableName(int columnIndex) throws SQLException {
        checkColRange(columnIndex);
        return colInfo[columnIndex].tableName;
    }

    Retrieves the catalog name of the table from which the value
in the designated column was derived.
Params: columnIndex – the first column is 1, the second is 2, and so on;
must be between 1 and the number of columns, inclusive
Throws: SQLException – if a database access error occurs
or the given column number is out of bounds
Returns: the catalog name of the column's table or an empty
        String if no catalog name is available/**
     * Retrieves the catalog name of the table from which the value
     * in the designated column was derived.
     *
     * @param columnIndex the first column is 1, the second is 2, and so on;
     * must be between <code>1</code> and the number of columns, inclusive
     * @return the catalog name of the column's table or an empty
     *         <code>String</code> if no catalog name is available
     * @throws SQLException if a database access error occurs
     * or the given column number is out of bounds
     */
    public String getCatalogName(int columnIndex) throws SQLException {
        checkColRange(columnIndex);
        String str ="";
        if(colInfo[columnIndex].catName == null){
        } else {
           str = colInfo[columnIndex].catName;
        }
        return str;
    }

    Retrieves the type code (one of the java.sql.Types
constants) for the SQL type of the value stored in the
designated column.
Params: columnIndex – the first column is 1, the second is 2, and so on;
must be between 1 and the number of columns, inclusive
Throws: SQLException – if a database access error occurs
or the given column number is out of bounds
See Also: Types
Returns: an int representing the SQL type of values
stored in the designated column/**
     * Retrieves the type code (one of the <code>java.sql.Types</code>
     * constants) for the SQL type of the value stored in the
     * designated column.
     *
     * @param columnIndex the first column is 1, the second is 2, and so on;
     * must be between <code>1</code> and the number of columns, inclusive
     * @return an <code>int</code> representing the SQL type of values
     * stored in the designated column
     * @throws SQLException if a database access error occurs
     * or the given column number is out of bounds
     * @see java.sql.Types
     */
    public int getColumnType(int columnIndex) throws SQLException {
        checkColRange(columnIndex);
        return colInfo[columnIndex].colType;
    }

    Retrieves the DBMS-specific type name for values stored in the
designated column.
Params: columnIndex – the first column is 1, the second is 2, and so on;
must be between 1 and the number of columns, inclusive
Throws: SQLException – if a database access error occurs
or the given column number is out of bounds
Returns: the type name used by the data source/**
     * Retrieves the DBMS-specific type name for values stored in the
     * designated column.
     *
     * @param columnIndex the first column is 1, the second is 2, and so on;
     * must be between <code>1</code> and the number of columns, inclusive
     * @return the type name used by the data source
     * @throws SQLException if a database access error occurs
     * or the given column number is out of bounds
     */
    public String getColumnTypeName(int columnIndex) throws SQLException {
        checkColRange(columnIndex);
        return colInfo[columnIndex].colTypeName;
    }


    Indicates whether the designated column is definitely
not writable, thus readonly.
Params: columnIndex – the first column is 1, the second is 2, and so on;
must be between 1 and the number of columns, inclusive
Throws: SQLException – if a database access error occurs
or the given column number is out of bounds
Returns: true if this RowSet object is read-Only
and thus not updatable; false otherwise/**
     * Indicates whether the designated column is definitely
     * not writable, thus readonly.
     *
     * @param columnIndex the first column is 1, the second is 2, and so on;
     * must be between <code>1</code> and the number of columns, inclusive
     * @return <code>true</code> if this <code>RowSet</code> object is read-Only
     * and thus not updatable; <code>false</code> otherwise
     * @throws SQLException if a database access error occurs
     * or the given column number is out of bounds
     */
    public boolean isReadOnly(int columnIndex) throws SQLException {
        checkColRange(columnIndex);
        return colInfo[columnIndex].readOnly;
    }

    Indicates whether it is possible for a write operation on
the designated column to succeed. A return value of
true means that a write operation may or may
not succeed.
Params: columnIndex – the first column is 1, the second is 2, and so on;
        must be between 1 and the number of columns, inclusive
Throws: SQLException – if a database access error occurs
        or the given column number is out of bounds
Returns: true if a write operation on the designated column may
         will succeed; false otherwise/**
     * Indicates whether it is possible for a write operation on
     * the designated column to succeed. A return value of
     * <code>true</code> means that a write operation may or may
     * not succeed.
     *
     * @param columnIndex the first column is 1, the second is 2, and so on;
     *         must be between <code>1</code> and the number of columns, inclusive
     * @return <code>true</code> if a write operation on the designated column may
     *          will succeed; <code>false</code> otherwise
     * @throws SQLException if a database access error occurs
     *         or the given column number is out of bounds
     */
    public boolean isWritable(int columnIndex) throws SQLException {
        checkColRange(columnIndex);
        return colInfo[columnIndex].writable;
    }

    Indicates whether a write operation on the designated column
will definitely succeed.
Params: columnIndex – the first column is 1, the second is 2, and so on;
must be between 1 and the number of columns, inclusive
Throws: SQLException – if a database access error occurs
or the given column number is out of bounds
Returns: true if a write operation on the designated column will
        definitely succeed; false otherwise/**
     * Indicates whether a write operation on the designated column
     * will definitely succeed.
     *
     * @param columnIndex the first column is 1, the second is 2, and so on;
     * must be between <code>1</code> and the number of columns, inclusive
     * @return <code>true</code> if a write operation on the designated column will
     *         definitely succeed; <code>false</code> otherwise
     * @throws SQLException if a database access error occurs
     * or the given column number is out of bounds
     */
    public  boolean isDefinitelyWritable(int columnIndex) throws SQLException {
        checkColRange(columnIndex);
        return true;
    }

    Retrieves the fully-qualified name of the class in the Java
programming language to which a value in the designated column
will be mapped.  For example, if the value is an int,
the class name returned by this method will be
java.lang.Integer.

If the value in the designated column has a custom mapping,
this method returns the name of the class that implements
SQLData. When the method ResultSet.getObject
is called to retrieve a value from the designated column, it will
create an instance of this class or one of its subclasses.
Params: columnIndex – the first column is 1, the second is 2, and so on;
       must be between 1 and the number of columns, inclusive
Throws: SQLException – if a database access error occurs
        or the given column number is out of bounds
Returns: the fully-qualified name of the class in the Java programming
       language that would be used by the method RowSet.getObject to
       retrieve the value in the specified column. This is the class
       name used for custom mapping when there is a custom mapping./**
     * Retrieves the fully-qualified name of the class in the Java
     * programming language to which a value in the designated column
     * will be mapped.  For example, if the value is an <code>int</code>,
     * the class name returned by this method will be
     * <code>java.lang.Integer</code>.
     * <P>
     * If the value in the designated column has a custom mapping,
     * this method returns the name of the class that implements
     * <code>SQLData</code>. When the method <code>ResultSet.getObject</code>
     * is called to retrieve a value from the designated column, it will
     * create an instance of this class or one of its subclasses.
     *
     * @param columnIndex the first column is 1, the second is 2, and so on;
     *        must be between <code>1</code> and the number of columns, inclusive
     * @return the fully-qualified name of the class in the Java programming
     *        language that would be used by the method <code>RowSet.getObject</code> to
     *        retrieve the value in the specified column. This is the class
     *        name used for custom mapping when there is a custom mapping.
     * @throws SQLException if a database access error occurs
     *         or the given column number is out of bounds
     */
    public String getColumnClassName(int columnIndex) throws SQLException {
        String className = String.class.getName();

        int sqlType = getColumnType(columnIndex);

        switch (sqlType) {

        case Types.NUMERIC:
        case Types.DECIMAL:
            className = java.math.BigDecimal.class.getName();
            break;

        case Types.BIT:
            className = java.lang.Boolean.class.getName();
            break;

        case Types.TINYINT:
            className = java.lang.Byte.class.getName();
            break;

        case Types.SMALLINT:
            className = java.lang.Short.class.getName();
            break;

        case Types.INTEGER:
            className = java.lang.Integer.class.getName();
            break;

        case Types.BIGINT:
            className = java.lang.Long.class.getName();
            break;

        case Types.REAL:
            className = java.lang.Float.class.getName();
            break;

        case Types.FLOAT:
        case Types.DOUBLE:
            className = java.lang.Double.class.getName();
            break;

        case Types.BINARY:
        case Types.VARBINARY:
        case Types.LONGVARBINARY:
            className = "byte[]";
            break;

        case Types.DATE:
            className = java.sql.Date.class.getName();
            break;

        case Types.TIME:
            className = java.sql.Time.class.getName();
            break;

        case Types.TIMESTAMP:
            className = java.sql.Timestamp.class.getName();
            break;

        case Types.BLOB:
            className = java.sql.Blob.class.getName();
            break;

        case Types.CLOB:
            className = java.sql.Clob.class.getName();
            break;
        }

        return className;
    }

    Returns an object that implements the given interface to allow access to non-standard methods,
or standard methods not exposed by the proxy.
The result may be either the object found to implement the interface or a proxy for that object.
If the receiver implements the interface then that is the object. If the receiver is a wrapper
and the wrapped object implements the interface then that is the object. Otherwise the object is
 the result of calling unwrap recursively on the wrapped object. If the receiver is not a
wrapper and does not implement the interface, then an SQLException is thrown.
Params: iface – A Class defining an interface that the result must implement.
Throws: SQLException – If no object found that implements the interface
Returns: an object that implements the interface. May be a proxy for the actual implementing object.
Since: 1.6/**
     * Returns an object that implements the given interface to allow access to non-standard methods,
     * or standard methods not exposed by the proxy.
     * The result may be either the object found to implement the interface or a proxy for that object.
     * If the receiver implements the interface then that is the object. If the receiver is a wrapper
     * and the wrapped object implements the interface then that is the object. Otherwise the object is
     *  the result of calling <code>unwrap</code> recursively on the wrapped object. If the receiver is not a
     * wrapper and does not implement the interface, then an <code>SQLException</code> is thrown.
     *
     * @param iface A Class defining an interface that the result must implement.
     * @return an object that implements the interface. May be a proxy for the actual implementing object.
     * @throws java.sql.SQLException If no object found that implements the interface
     * @since 1.6
     */
    public <T> T unwrap(java.lang.Class<T> iface) throws java.sql.SQLException {

        if(isWrapperFor(iface)) {
            return iface.cast(this);
        } else {
            throw new SQLException("unwrap failed for:"+ iface);
        }
    }

    Returns true if this either implements the interface argument or is directly or indirectly a wrapper
for an object that does. Returns false otherwise. If this implements the interface then return true,
else if this is a wrapper then return the result of recursively calling isWrapperFor on the wrapped
object. If this does not implement the interface and is not a wrapper, return false.
This method should be implemented as a low-cost operation compared to unwrap so that
callers can use this method to avoid expensive unwrap calls that may fail. If this method
returns true then calling unwrap with the same argument should succeed.
Params: interfaces – a Class defining an interface.
Throws: SQLException –  if an error occurs while determining whether this is a wrapper
for an object with the given interface.
Returns: true if this implements the interface or directly or indirectly wraps an object that does.
Since: 1.6/**
     * Returns true if this either implements the interface argument or is directly or indirectly a wrapper
     * for an object that does. Returns false otherwise. If this implements the interface then return true,
     * else if this is a wrapper then return the result of recursively calling <code>isWrapperFor</code> on the wrapped
     * object. If this does not implement the interface and is not a wrapper, return false.
     * This method should be implemented as a low-cost operation compared to <code>unwrap</code> so that
     * callers can use this method to avoid expensive <code>unwrap</code> calls that may fail. If this method
     * returns true then calling <code>unwrap</code> with the same argument should succeed.
     *
     * @param interfaces a Class defining an interface.
     * @return true if this implements the interface or directly or indirectly wraps an object that does.
     * @throws java.sql.SQLException  if an error occurs while determining whether this is a wrapper
     * for an object with the given interface.
     * @since 1.6
     */
    public boolean isWrapperFor(Class<?> interfaces) throws SQLException {
        return interfaces.isInstance(this);
    }

    static final long serialVersionUID = 6893806403181801867L;

    private class ColInfo implements Serializable {
        The field that indicates whether the value in this column is a number
that is incremented automatically, which makes the value read-only.
true means that the value in this column
is automatically numbered; false means that it is not.
@serial /**
         * The field that indicates whether the value in this column is a number
         * that is incremented automatically, which makes the value read-only.
         * <code>true</code> means that the value in this column
         * is automatically numbered; <code>false</code> means that it is not.
         *
         * @serial
         */
        public boolean autoIncrement;

        The field that indicates whether the value in this column is case sensitive.
true means that it is; false that it is not.
@serial /**
         * The field that indicates whether the value in this column is case sensitive.
         * <code>true</code> means that it is; <code>false</code> that it is not.
         *
         * @serial
         */
        public boolean caseSensitive;

        The field that indicates whether the value in this column is a cash value
true means that it is; false that it is not.
@serial /**
         * The field that indicates whether the value in this column is a cash value
         * <code>true</code> means that it is; <code>false</code> that it is not.
         *
         * @serial
         */
        public boolean currency;

        The field that indicates whether the value in this column is nullable.
The possible values are the ResultSet constants
columnNoNulls, columnNullable, and
columnNullableUnknown.
@serial /**
         * The field that indicates whether the value in this column is nullable.
         * The possible values are the <code>ResultSet</code> constants
         * <code>columnNoNulls</code>, <code>columnNullable</code>, and
         * <code>columnNullableUnknown</code>.
         *
         * @serial
         */
        public int nullable;

        The field that indicates whether the value in this column is a signed number.
true means that it is; false that it is not.
@serial /**
         * The field that indicates whether the value in this column is a signed number.
         * <code>true</code> means that it is; <code>false</code> that it is not.
         *
         * @serial
         */
        public boolean signed;

        The field that indicates whether the value in this column can be used in
a WHERE clause.
true means that it can; false that it cannot.
@serial /**
         * The field that indicates whether the value in this column can be used in
         * a <code>WHERE</code> clause.
         * <code>true</code> means that it can; <code>false</code> that it cannot.
         *
         * @serial
         */
        public boolean searchable;

        The field that indicates the normal maximum width in characters for
this column.
@serial /**
         * The field that indicates the normal maximum width in characters for
         * this column.
         *
         * @serial
         */
        public int columnDisplaySize;

        The field that holds the suggested column title for this column, to be
used in printing and displays.
@serial /**
         * The field that holds the suggested column title for this column, to be
         * used in printing and displays.
         *
         * @serial
         */
        public String columnLabel;

        The field that holds the name of this column.
@serial /**
         * The field that holds the name of this column.
         *
         * @serial
         */
        public  String columnName;

        The field that holds the schema name for the table from which this column
was derived.
@serial /**
         * The field that holds the schema name for the table from which this column
         * was derived.
         *
         * @serial
         */
        public String schemaName;

        The field that holds the precision of the value in this column.  For number
types, the precision is the total number of decimal digits; for character types,
it is the maximum number of characters; for binary types, it is the maximum
length in bytes.
@serial /**
         * The field that holds the precision of the value in this column.  For number
         * types, the precision is the total number of decimal digits; for character types,
         * it is the maximum number of characters; for binary types, it is the maximum
         * length in bytes.
         *
         * @serial
         */
        public int colPrecision;

        The field that holds the scale (number of digits to the right of the decimal
point) of the value in this column.
@serial /**
         * The field that holds the scale (number of digits to the right of the decimal
         * point) of the value in this column.
         *
         * @serial
         */
        public int colScale;

        The field that holds the name of the table from which this column
was derived.  This value may be the empty string if there is no
table name, such as when this column is produced by a join.
@serial /**
         * The field that holds the name of the table from which this column
         * was derived.  This value may be the empty string if there is no
         * table name, such as when this column is produced by a join.
         *
         * @serial
         */
        public String tableName ="";

        The field that holds the catalog name for the table from which this column
was derived.  If the DBMS does not support catalogs, the value may be the
empty string.
@serial /**
         * The field that holds the catalog name for the table from which this column
         * was derived.  If the DBMS does not support catalogs, the value may be the
         * empty string.
         *
         * @serial
         */
        public String catName;

        The field that holds the type code from the class java.sql.Types
indicating the type of the value in this column.
@serial /**
         * The field that holds the type code from the class <code>java.sql.Types</code>
         * indicating the type of the value in this column.
         *
         * @serial
         */
        public int colType;

        The field that holds the type name used by this particular data source
for the value stored in this column.
@serial /**
         * The field that holds the type name used by this particular data source
         * for the value stored in this column.
         *
         * @serial
         */
        public String colTypeName;

        The field that holds the updatability boolean per column of a RowSet
@serial /**
         * The field that holds the updatability boolean per column of a RowSet
         *
         * @serial
         */
        public boolean readOnly = false;

        The field that hold the writable boolean per column of a RowSet
@serial /**
         * The field that hold the writable boolean per column of a RowSet
         *
         *@serial
         */
        public boolean writable = true;

        static final long serialVersionUID = 5490834817919311283L;
    }
}
Params:	SQLType – an `int` defined in the class `java.sql.Types`
Throws:	SQLException – if the given `int` is not a constant defined in the class `java.sql.Types`
Params:	columnCount – an `int` giving the number of columns in the `RowSet` object
Throws:	SQLException – if the given number is equal to or less than zero
Params:	columnIndex – the first column is 1, the second is 2, and so on; must be between `1` and the number of columns in the rowset, inclusive property – `true` if the given column is automatically incremented; `false` otherwise
Throws:	SQLException – if a database access error occurs or the given index is out of bounds
Throws:	SQLException – if an error occurs determining the column count
Returns:	the number of columns
Params:	iface – A Class defining an interface that the result must implement.
Throws:	SQLException – If no object found that implements the interface
Returns:	an object that implements the interface. May be a proxy for the actual implementing object.
Since:	1.6
Params:	interfaces – a Class defining an interface.
Throws:	SQLException – if an error occurs while determining whether this is a wrapper for an object with the given interface.
Returns:	true if this implements the interface or directly or indirectly wraps an object that does.
Since:	1.6
/

java/ 8/ javax/sql/rowset/RowSetMetaDataImpl.java
