* @throws java.sql.SQLException if a database access error occurs     * @see java.sql.Types     */    public int getColumnType(int column) throws java.sql.SQLException {        return getField(column).getSQLType();    }    /**     * Whats is the column's data source specific type name?     *     * @param column the first column is 1, the second is 2, etc.     * @return the type name     * @throws java.sql.SQLException if a database access error occurs     */    public String getColumnTypeName(int column) throws java.sql.SQLException {    	Field field = getField(column);    	        int mysqlType = field.getMysqlType();        switch (mysqlType) {        case MysqlDefs.FIELD_TYPE_DECIMAL:            return field.isUnsigned() ? "DECIMAL UNSIGNED" : "DECIMAL";        case MysqlDefs.FIELD_TYPE_TINY:            return field.isUnsigned() ? "TINYINT UNSIGNED" : "TINYINT";        case MysqlDefs.FIELD_TYPE_SHORT:            return field.isUnsigned() ? "SMALLINT UNSIGNED" : "SMALLINT";        case MysqlDefs.FIELD_TYPE_LONG:            return field.isUnsigned() ? "INTEGER UNSIGNED" : "INTEGER";        case MysqlDefs.FIELD_TYPE_FLOAT:            return field.isUnsigned() ? "FLOAT UNSIGNED" : "FLOAT";        case MysqlDefs.FIELD_TYPE_DOUBLE:            return field.isUnsigned() ? "DOUBLE UNSIGNED" : "DOUBLE";        case MysqlDefs.FIELD_TYPE_NULL:            return "NULL";        case MysqlDefs.FIELD_TYPE_TIMESTAMP:            return "TIMESTAMP";        case MysqlDefs.FIELD_TYPE_LONGLONG:            return field.isUnsigned() ? "BIGINT UNSIGNED" : "BIGINT";        case MysqlDefs.FIELD_TYPE_INT24:            return field.isUnsigned() ? "MEDIUMINT UNSIGNED" : "MEDIUMINT";        case MysqlDefs.FIELD_TYPE_DATE:            return "DATE";        case MysqlDefs.FIELD_TYPE_TIME:            return "TIME";        case MysqlDefs.FIELD_TYPE_DATETIME:            return "DATETIME";        case MysqlDefs.FIELD_TYPE_TINY_BLOB:            return "TINYBLOB";        case MysqlDefs.FIELD_TYPE_MEDIUM_BLOB:            return "MEDIUMBLOB";        case MysqlDefs.FIELD_TYPE_LONG_BLOB:            return "LONGBLOB";        case MysqlDefs.FIELD_TYPE_BLOB:            if (getField(column).isBinary()) {                return "BLOB";            } else {                return "TEXT";            }        case MysqlDefs.FIELD_TYPE_VAR_STRING:            return "VARCHAR";        case MysqlDefs.FIELD_TYPE_STRING:            return "CHAR";        case MysqlDefs.FIELD_TYPE_ENUM:            return "ENUM";        case MysqlDefs.FIELD_TYPE_SET:            return "SET";                   case MysqlDefs.FIELD_TYPE_YEAR:        	return "YEAR";        default:            return "UNKNOWN";        }    }    /**     * Is the column a cash value?     *     * @param column the first column is 1, the second is 2...     * @return true if its a cash column     * @throws java.sql.SQLException if a database access error occurs     */    public boolean isCurrency(int column) throws java.sql.SQLException {        return false;    }    /**     * Will a write on this column definately succeed?     *     * @param column the first column is 1, the second is 2, etc..     * @return true if so     * @throws java.sql.SQLException if a database access error occurs     */    public boolean isDefinitelyWritable(int column)        throws java.sql.SQLException {        return isWritable(column);    }    /**     * Can you put a NULL in this column?     *     * @param column the first column is 1, the second is 2...     * @return one of the columnNullable values     * @throws java.sql.SQLException if a database access error occurs     */    public int isNullable(int column) throws java.sql.SQLException {        if (!getField(column).isNotNull()) {            return java.sql.ResultSetMetaData.columnNullable;        } else {            return java.sql.ResultSetMetaData.columnNoNulls;        }    }    /**     * What is a column's number of decimal digits.     *     * @param column the first column is 1, the second is 2...     * @return the precision     * @throws java.sql.SQLException if a database access error occurs     */    public int getPrecision(int column) throws java.sql.SQLException {        Field f = getField(column);        if (isDecimalType(f.getSQLType())) {            if (f.getDecimals() > 0) {                return (int)(f.getLength() - 1 + f.getPrecisionAdjustFactor());            }            return (int)(f.getLength() + f.getPrecisionAdjustFactor());        }        switch (f.getMysqlType()) {        case MysqlDefs.FIELD_TYPE_TINY_BLOB:        case MysqlDefs.FIELD_TYPE_BLOB:        case MysqlDefs.FIELD_TYPE_MEDIUM_BLOB:        case MysqlDefs.FIELD_TYPE_LONG_BLOB:        	return (int)f.getLength(); // this may change in the future                                  // for now, the server only                                  // returns FIELD_TYPE_BLOB for _all_                                  // BLOB types, but varying lengths                                  // indicating the _maximum_ size                                  // for each BLOB type.        default:        	return (int)f.getLength();                        }    }    /**     * Is the column definitely not writable?     *     * @param column the first column is 1, the second is 2, etc.     * @return true if so     * @throws java.sql.SQLException if a database access error occurs     */    public boolean isReadOnly(int column) throws java.sql.SQLException {        return getField(column).isReadOnly();    }    /**     * What is a column's number of digits to the right of the     * decimal point?     *     * @param column the first column is 1, the second is 2...     * @return the scale     * @throws java.sql.SQLException if a database access error occurs     */    public int getScale(int column) throws java.sql.SQLException {        Field f = getField(column);        if (isDecimalType(f.getSQLType())) {            return f.getDecimals();        }        return 0;    }    /**     * What is a column's table's schema?  This relies on us knowing     * the table name.     *     * The JDBC specification allows us to return "" if this is not     * applicable.     *     * @param column the first column is 1, the second is 2...     * @return the Schema     * @throws java.sql.SQLException if a database access error occurs     */    public String getSchemaName(int column) throws java.sql.SQLException {        return "";    }    /**     * Can the column be used in a WHERE clause?  Basically for     * this, I split the functions into two types: recognised     * types (which are always useable), and OTHER types (which     * may or may not be useable).  The OTHER types, for now, I     * will assume they are useable.  We should really query the     * catalog to see if they are useable.     *     * @param column the first column is 1, the second is 2...     * @return true if they can be used in a WHERE clause     * @throws java.sql.SQLException if a database access error occurs     */    public boolean isSearchable(int column) throws java.sql.SQLException {        return true;    }    /**     * Is the column a signed number?     *     * @param column the first column is 1, the second is 2...     * @return true if so     * @throws java.sql.SQLException if a database access error occurs     */    public boolean isSigned(int column) throws java.sql.SQLException {        Field f = getField(column);        int sqlType = f.getSQLType();        switch (sqlType) {        case Types.TINYINT:        case Types.SMALLINT:        case Types.INTEGER:        case Types.BIGINT:        case Types.FLOAT:        case Types.REAL:        case Types.DOUBLE:        case Types.NUMERIC:        case Types.DECIMAL:            return !f.isUnsigned();        case Types.DATE:        case Types.TIME:        case Types.TIMESTAMP:            return false;        default:            return false;        }    }    /**     * Whats a column's table's name?     *     * @param column the first column is 1, the second is 2...     * @return column name, or "" if not applicable     * @throws java.sql.SQLException if a database access error occurs     */    public String getTableName(int column) throws java.sql.SQLException {        return getField(column).getTableName();    }    /**     * Is it possible for a write on the column to succeed?     *     * @param column the first column is 1, the second is 2, etc.     * @return true if so     * @throws java.sql.SQLException if a database access error occurs     */    public boolean isWritable(int column) throws java.sql.SQLException {        return !isReadOnly(column);    }    // *********************************************************************    //    //                END OF PUBLIC INTERFACE    //    // *********************************************************************    /**     * Returns the field instance for the given column index     *     * @param columnIndex the column number to retrieve a field instance for     * @return the field instance for the given column index     *     * @throws java.sql.SQLException if an error occurs     */    protected Field getField(int columnIndex) throws java.sql.SQLException {        if ((columnIndex < 1) || (columnIndex > fields.length)) {            throw new java.sql.SQLException("Column index out of range.",                SQLError.SQL_STATE_INVALID_COLUMN_NUMBER);        }        return fields[columnIndex - 1];    }    /**     * Checks if the SQL Type is a Decimal/Number Type     * @param type SQL Type     */    private static final boolean isDecimalType(int type) {        switch (type) {        case Types.BIT:        case Types.TINYINT:        case Types.SMALLINT:        case Types.INTEGER:        case Types.BIGINT:        case Types.FLOAT:        case Types.REAL:        case Types.DOUBLE:        case Types.NUMERIC:        case Types.DECIMAL:            return true;        }        return false;    }}