1102 lines
43 KiB
1102 lines
43 KiB
/*
|
|
* Copyright (c) 2003, 2014, Oracle and/or its affiliates. All rights reserved.
|
|
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*/
|
|
|
|
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 <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 <code>RowSet</code> object that created
|
|
* this <code>RowSetMetaDataImpl</code> object.
|
|
* @serial
|
|
*/
|
|
private int colCount;
|
|
|
|
/**
|
|
* 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 <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
|
|
* <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 <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 <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 <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 <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 <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 <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 <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.
|
|
*
|
|
* @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 <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.
|
|
*
|
|
* @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
|
|
* <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.
|
|
*
|
|
* @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.
|
|
*
|
|
* @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.
|
|
*
|
|
* @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 <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 <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.
|
|
*
|
|
* @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 <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.
|
|
*
|
|
* @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.
|
|
*
|
|
* @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 <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.
|
|
*
|
|
* @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 <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.
|
|
*
|
|
* @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.
|
|
*
|
|
* @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.
|
|
*
|
|
* @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.
|
|
*
|
|
* @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.
|
|
*
|
|
* @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.
|
|
*
|
|
* @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.
|
|
*
|
|
* @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.
|
|
*
|
|
* @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.
|
|
*
|
|
* @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 <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.
|
|
*
|
|
* @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.
|
|
*
|
|
* @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
|
|
* <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.
|
|
*
|
|
* @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 <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 <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 <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.
|
|
* <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.
|
|
* <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
|
|
* <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 <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.
|
|
* <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 <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
|
|
*/
|
|
public int columnDisplaySize;
|
|
|
|
/**
|
|
* 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
|
|
*/
|
|
public String columnName;
|
|
|
|
/**
|
|
* 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
|
|
*/
|
|
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
|
|
*/
|
|
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
|
|
*/
|
|
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
|
|
*/
|
|
public String catName;
|
|
|
|
/**
|
|
* 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
|
|
*/
|
|
public String colTypeName;
|
|
|
|
/**
|
|
* 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
|
|
*/
|
|
public boolean writable = true;
|
|
|
|
static final long serialVersionUID = 5490834817919311283L;
|
|
}
|
|
}
|