cursor.java

derby database source code.good for you.

        case java.sql.Types.CHAR:
            return agent_.crossConverters_.getBooleanFromString(getCHAR(column));
        case java.sql.Types.VARCHAR:
        case java.sql.Types.LONGVARCHAR:
            return agent_.crossConverters_.getBooleanFromString(getVARCHAR(column));
        default:
            throw new ColumnTypeConversionException(agent_.logWriter_);
        }
    }

    final byte getByte(int column) throws SqlException {
        // This needs to be changed to use jdbcTypes[]
        switch (jdbcTypes_[column - 1]) {
        case java.sql.Types.SMALLINT:
            return agent_.crossConverters_.getByteFromShort(get_SMALLINT(column));
        case java.sql.Types.INTEGER:
            return agent_.crossConverters_.getByteFromInt(get_INTEGER(column));
        case java.sql.Types.BIGINT:
            return agent_.crossConverters_.getByteFromLong(get_BIGINT(column));
        case java.sql.Types.REAL:
            return agent_.crossConverters_.getByteFromFloat(get_FLOAT(column));
        case java.sql.Types.DOUBLE:
            return agent_.crossConverters_.getByteFromDouble(get_DOUBLE(column));
        case java.sql.Types.DECIMAL:
            // For performance we don't materialize the BigDecimal, but convert directly from decimal bytes to a long.
            return agent_.crossConverters_.getByteFromLong(getLongFromDECIMAL(column));
        case java.sql.Types.CHAR:
            return agent_.crossConverters_.getByteFromString(getCHAR(column));
        case java.sql.Types.VARCHAR:
        case java.sql.Types.LONGVARCHAR:
            return agent_.crossConverters_.getByteFromString(getVARCHAR(column));
        default:
            throw new ColumnTypeConversionException(agent_.logWriter_);
        }
    }

    final short getShort(int column) throws SqlException {
        switch (jdbcTypes_[column - 1]) {
        case java.sql.Types.SMALLINT:
            return get_SMALLINT(column);
        case java.sql.Types.INTEGER:
            return agent_.crossConverters_.getShortFromInt(get_INTEGER(column));
        case java.sql.Types.BIGINT:
            return agent_.crossConverters_.getShortFromLong(get_BIGINT(column));
        case java.sql.Types.REAL:
            return agent_.crossConverters_.getShortFromFloat(get_FLOAT(column));
        case java.sql.Types.DOUBLE:
            return agent_.crossConverters_.getShortFromDouble(get_DOUBLE(column));
        case java.sql.Types.DECIMAL:
            // For performance we don't materialize the BigDecimal, but convert directly from decimal bytes to a long.
            return agent_.crossConverters_.getShortFromLong(getLongFromDECIMAL(column));
        case java.sql.Types.CHAR:
            return agent_.crossConverters_.getShortFromString(getCHAR(column));
        case java.sql.Types.VARCHAR:
        case java.sql.Types.LONGVARCHAR:
            return agent_.crossConverters_.getShortFromString(getVARCHAR(column));
        default:
            throw new ColumnTypeConversionException(agent_.logWriter_);
        }
    }

    final int getInt(int column) throws SqlException {
        switch (jdbcTypes_[column - 1]) {
        case java.sql.Types.SMALLINT:
            return (int) get_SMALLINT(column);
        case java.sql.Types.INTEGER:
            return get_INTEGER(column);
        case java.sql.Types.BIGINT:
            return agent_.crossConverters_.getIntFromLong(get_BIGINT(column));
        case java.sql.Types.REAL:
            return agent_.crossConverters_.getIntFromFloat(get_FLOAT(column));
        case java.sql.Types.DOUBLE:
            return agent_.crossConverters_.getIntFromDouble(get_DOUBLE(column));
        case java.sql.Types.DECIMAL:
            // For performance we don't materialize the BigDecimal, but convert directly from decimal bytes to a long.
            return agent_.crossConverters_.getIntFromLong(getLongFromDECIMAL(column));
        case java.sql.Types.CHAR:
            return agent_.crossConverters_.getIntFromString(getCHAR(column));
        case java.sql.Types.VARCHAR:
        case java.sql.Types.LONGVARCHAR:
            return agent_.crossConverters_.getIntFromString(getVARCHAR(column));
        default:
            throw new ColumnTypeConversionException(agent_.logWriter_);
        }
    }

    final long getLong(int column) throws SqlException {
        switch (jdbcTypes_[column - 1]) {
        case java.sql.Types.SMALLINT:
            return (long) get_SMALLINT(column);
        case java.sql.Types.INTEGER:
            return (long) get_INTEGER(column);
        case java.sql.Types.BIGINT:
            return get_BIGINT(column);
        case java.sql.Types.REAL:
            return agent_.crossConverters_.getLongFromFloat(get_FLOAT(column));
        case java.sql.Types.DOUBLE:
            return agent_.crossConverters_.getLongFromDouble(get_DOUBLE(column));
        case java.sql.Types.DECIMAL:
            // For performance we don't materialize the BigDecimal, but convert directly from decimal bytes to a long.
            return getLongFromDECIMAL(column);
        case java.sql.Types.CHAR:
            return agent_.crossConverters_.getLongFromString(getCHAR(column));
        case java.sql.Types.VARCHAR:
        case java.sql.Types.LONGVARCHAR:
            return agent_.crossConverters_.getLongFromString(getVARCHAR(column));
        default:
            throw new ColumnTypeConversionException(agent_.logWriter_);
        }
    }

    final float getFloat(int column) throws SqlException {
        switch (jdbcTypes_[column - 1]) {
        case java.sql.Types.REAL:
            return get_FLOAT(column);
        case java.sql.Types.DOUBLE:
            return agent_.crossConverters_.getFloatFromDouble(get_DOUBLE(column));
        case java.sql.Types.DECIMAL:
            // For performance we don't materialize the BigDecimal, but convert directly from decimal bytes to a long.
            return agent_.crossConverters_.getFloatFromDouble(getDoubleFromDECIMAL(column));
        case java.sql.Types.SMALLINT:
            return (float) get_SMALLINT(column);
        case java.sql.Types.INTEGER:
            return (float) get_INTEGER(column);
        case java.sql.Types.BIGINT:
            return (float) get_BIGINT(column);
        case java.sql.Types.CHAR:
            return agent_.crossConverters_.getFloatFromString(getCHAR(column));
        case java.sql.Types.VARCHAR:
        case java.sql.Types.LONGVARCHAR:
            return agent_.crossConverters_.getFloatFromString(getVARCHAR(column));
        default:
            throw new ColumnTypeConversionException(agent_.logWriter_);
        }
    }

    final double getDouble(int column) throws SqlException {
        switch (jdbcTypes_[column - 1]) {
        case java.sql.Types.REAL:
            double d = (double) get_FLOAT(column);
            return d;
            //return (double) get_FLOAT (column);
        case java.sql.Types.DOUBLE:
            return get_DOUBLE(column);
        case java.sql.Types.DECIMAL:
            // For performance we don't materialize the BigDecimal, but convert directly from decimal bytes to a long.
            return getDoubleFromDECIMAL(column);
        case java.sql.Types.SMALLINT:
            return (double) get_SMALLINT(column);
        case java.sql.Types.INTEGER:
            return (double) get_INTEGER(column);
        case java.sql.Types.BIGINT:
            return (double) get_BIGINT(column);
        case java.sql.Types.CHAR:
            return agent_.crossConverters_.getDoubleFromString(getCHAR(column));
        case java.sql.Types.VARCHAR:
        case java.sql.Types.LONGVARCHAR:
            return agent_.crossConverters_.getDoubleFromString(getVARCHAR(column));
        default:
            throw new ColumnTypeConversionException(agent_.logWriter_);
        }
    }

    final java.math.BigDecimal getBigDecimal(int column) throws SqlException {
        switch (jdbcTypes_[column - 1]) {
        case java.sql.Types.DECIMAL:
            return get_DECIMAL(column);
        case java.sql.Types.REAL:
            // Can't use the following commented out line because it changes precision of the result.
            //return new java.math.BigDecimal (get_FLOAT (column));
            float f = get_FLOAT(column);
            return new java.math.BigDecimal(String.valueOf(f));
        case java.sql.Types.DOUBLE:
            // Can't use the following commented out line because it changes precision of the result.
            return new java.math.BigDecimal(String.valueOf(get_DOUBLE(column)));
        case java.sql.Types.SMALLINT:
            return java.math.BigDecimal.valueOf(get_SMALLINT(column));
        case java.sql.Types.INTEGER:
            return java.math.BigDecimal.valueOf(get_INTEGER(column));
        case java.sql.Types.BIGINT:
            return java.math.BigDecimal.valueOf(get_BIGINT(column));
        case java.sql.Types.CHAR:
            return agent_.crossConverters_.getBigDecimalFromString(getCHAR(column));
        case java.sql.Types.VARCHAR:
        case java.sql.Types.LONGVARCHAR:
            return agent_.crossConverters_.getBigDecimalFromString(getVARCHAR(column));
        default:
            throw new ColumnTypeConversionException(agent_.logWriter_);
        }
    }

    final java.sql.Date getDate(int column) throws SqlException {
        switch (jdbcTypes_[column - 1]) {
        case java.sql.Types.DATE:
            return getDATE(column);
        case java.sql.Types.TIMESTAMP:
            return getDateFromTIMESTAMP(column);
        case java.sql.Types.CHAR:
            return agent_.crossConverters_.getDateFromString(getCHAR(column));
        case java.sql.Types.VARCHAR:
        case java.sql.Types.LONGVARCHAR:
            return agent_.crossConverters_.getDateFromString(getVARCHAR(column));
        default:
            throw new ColumnTypeConversionException(agent_.logWriter_);
        }
    }

    final java.sql.Time getTime(int column) throws SqlException {
        switch (jdbcTypes_[column - 1]) {
        case java.sql.Types.TIME:
            return getTIME(column);
        case java.sql.Types.TIMESTAMP:
            return getTimeFromTIMESTAMP(column);
        case java.sql.Types.CHAR:
            return agent_.crossConverters_.getTimeFromString(getCHAR(column));
        case java.sql.Types.VARCHAR:
        case java.sql.Types.LONGVARCHAR:
            return agent_.crossConverters_.getTimeFromString(getVARCHAR(column));
        default:
            throw new ColumnTypeConversionException(agent_.logWriter_);
        }
    }

    final java.sql.Timestamp getTimestamp(int column) throws SqlException {
        switch (jdbcTypes_[column - 1]) {
        case java.sql.Types.TIMESTAMP:
            return getTIMESTAMP(column);
        case java.sql.Types.DATE:
            return getTimestampFromDATE(column);
        case java.sql.Types.TIME:
            return getTimestampFromTIME(column);
        case java.sql.Types.CHAR:
            return agent_.crossConverters_.getTimestampFromString(getCHAR(column));
        case java.sql.Types.VARCHAR:
        case java.sql.Types.LONGVARCHAR:
            return agent_.crossConverters_.getTimestampFromString(getVARCHAR(column));
        default:
            throw new ColumnTypeConversionException(agent_.logWriter_);
        }
    }

    final String getString(int column) throws SqlException {
        String tempString = null;
        switch (jdbcTypes_[column - 1]) {
        case java.sql.Types.CHAR:
            return getCHAR(column);
        case java.sql.Types.VARCHAR:
        case java.sql.Types.LONGVARCHAR:
            return getVARCHAR(column);

        case java.sql.Types.SMALLINT:
            return String.valueOf(get_SMALLINT(column));
        case java.sql.Types.INTEGER:
            return String.valueOf(get_INTEGER(column));
        case java.sql.Types.BIGINT:
            return String.valueOf(get_BIGINT(column));
        case java.sql.Types.REAL:
            return String.valueOf(get_FLOAT(column));
        case java.sql.Types.DOUBLE:
            return String.valueOf(get_DOUBLE(column));
        case java.sql.Types.DECIMAL:
            // We could get better performance here if we didn't materialize the BigDecimal,
            // but converted directly from decimal bytes to a string.
            return String.valueOf(get_DECIMAL(column));
        case java.sql.Types.DATE:
            return getStringFromDATE(column);
        case java.sql.Types.TIME:
            return getStringFromTIME(column);
        case java.sql.Types.TIMESTAMP:
            return getStringFromTIMESTAMP(column);
        case Types.BINARY:
            tempString =
                    agent_.crossConverters_.getStringFromBytes(get_CHAR_FOR_BIT_DATA(column));
            return (maxFieldSize_ == 0) ? tempString :
                    tempString.substring(0, java.lang.Math.min(maxFieldSize_, tempString.length()));
        case java.sql.Types.VARBINARY:
        case java.sql.Types.LONGVARBINARY:
            tempString =
                    agent_.crossConverters_.getStringFromBytes(get_VARCHAR_FOR_BIT_DATA(column));
            return (maxFieldSize_ == 0) ? tempString :