cursor.java

derby database source code.good for you.

                    tempString.substring(0, java.lang.Math.min(maxFieldSize_, tempString.length()));
        case java.sql.Types.BLOB:
            Blob b = (Blob) getBlobColumn_(column, agent_);
            return agent_.crossConverters_.getStringFromBytes(b.getBytes(1, (int) b.length()));
        case java.sql.Types.CLOB:
            Clob c = getClobColumn_(column, agent_);
            return c.getSubString(1, (int) c.length());
        default:
            throw new ColumnTypeConversionException(agent_.logWriter_);
        }
    }

    final byte[] getBytes(int column) throws SqlException {
        switch (jdbcTypes_[column - 1]) {
        case java.sql.Types.BINARY:
            return get_CHAR_FOR_BIT_DATA(column);
        case java.sql.Types.VARBINARY:
        case java.sql.Types.LONGVARBINARY:
            return get_VARCHAR_FOR_BIT_DATA(column);
        case java.sql.Types.BLOB:
            Blob b = (Blob) getBlobColumn_(column, agent_);
            return b.getBytes(1, (int) b.length());
        default:
            throw new ColumnTypeConversionException(agent_.logWriter_);
        }
    }

    public final java.io.InputStream getBinaryStream(int column) throws SqlException {
        switch (jdbcTypes_[column - 1]) {
        case java.sql.Types.BINARY:
            return new java.io.ByteArrayInputStream(get_CHAR_FOR_BIT_DATA(column));
        case java.sql.Types.VARBINARY:
        case java.sql.Types.LONGVARBINARY:
            return new java.io.ByteArrayInputStream(get_VARCHAR_FOR_BIT_DATA(column));
        case java.sql.Types.BLOB:
            Blob b = (Blob) getBlobColumn_(column, agent_);
            return b.getBinaryStream();
        default:
            throw new ColumnTypeConversionException(agent_.logWriter_);
        }
    }

    public final java.io.InputStream getAsciiStream(int column) throws SqlException {
        switch (jdbcTypes_[column - 1]) {
        case java.sql.Types.CLOB:
            Clob c = getClobColumn_(column, agent_);
            return c.getAsciiStream();
        case java.sql.Types.CHAR:
            try {
                return new java.io.ByteArrayInputStream(getCHAR(column).getBytes("US-ASCII"));
            } catch (java.io.UnsupportedEncodingException e) {
                throw new SqlException(agent_.logWriter_, e.getMessage());
            }
        case java.sql.Types.VARCHAR:
        case java.sql.Types.LONGVARCHAR:
            try {
                return new java.io.ByteArrayInputStream(getVARCHAR(column).getBytes("US-ASCII"));
            } catch (java.io.UnsupportedEncodingException e) {
                throw new SqlException(agent_.logWriter_, e.getMessage());
            }
        case java.sql.Types.BINARY:
            return new java.io.ByteArrayInputStream(get_CHAR_FOR_BIT_DATA(column));
        case java.sql.Types.VARBINARY:
        case java.sql.Types.LONGVARBINARY:
            return new java.io.ByteArrayInputStream(get_VARCHAR_FOR_BIT_DATA(column));
        case java.sql.Types.BLOB:
            Blob b = (Blob) getBlobColumn_(column, agent_);
            return b.getBinaryStream();
        default:
            throw new ColumnTypeConversionException(agent_.logWriter_);
        }
    }

    public final java.io.InputStream getUnicodeStream(int column) throws SqlException {
        switch (jdbcTypes_[column - 1]) {
        case java.sql.Types.CLOB:
            {
                Clob c = getClobColumn_(column, agent_);
                String s = c.getSubString(1L, (int) c.length());
                try {
                    return new java.io.ByteArrayInputStream(s.getBytes("UTF-8"));
                } catch (java.io.UnsupportedEncodingException e) {
                    throw new SqlException(agent_.logWriter_, e.getMessage());
                }
            }
        case java.sql.Types.CHAR:
            {
                try {
                    return new java.io.ByteArrayInputStream(getCHAR(column).getBytes("UTF-8"));
                } catch (java.io.UnsupportedEncodingException e) {
                    throw new SqlException(agent_.logWriter_, e.getMessage());
                }
            }
        case java.sql.Types.VARCHAR:
        case java.sql.Types.LONGVARCHAR:
            try {
                return new java.io.ByteArrayInputStream(getVARCHAR(column).getBytes("UTF-8"));
            } catch (java.io.UnsupportedEncodingException e) {
                throw new SqlException(agent_.logWriter_, e.getMessage());
            }
        case java.sql.Types.BINARY:
            return new java.io.ByteArrayInputStream(get_CHAR_FOR_BIT_DATA(column));
        case java.sql.Types.VARBINARY:
        case java.sql.Types.LONGVARBINARY:
            return new java.io.ByteArrayInputStream(get_VARCHAR_FOR_BIT_DATA(column));
        case java.sql.Types.BLOB:
            Blob b = (Blob) getBlobColumn_(column, agent_);
            return b.getBinaryStream();
        default:
            throw new ColumnTypeConversionException(agent_.logWriter_);
        }
    }

    public final java.io.Reader getCharacterStream(int column) throws SqlException {
        switch (jdbcTypes_[column - 1]) {
        case java.sql.Types.CLOB:
            Clob c = getClobColumn_(column, agent_);
            return c.getCharacterStream();
        case java.sql.Types.CHAR:
            return new java.io.StringReader(getCHAR(column));
        case java.sql.Types.VARCHAR:
        case java.sql.Types.LONGVARCHAR:
            return new java.io.StringReader(getVARCHAR(column));
        case java.sql.Types.BINARY:
            try {
                return new java.io.InputStreamReader(new java.io.ByteArrayInputStream(get_CHAR_FOR_BIT_DATA(column)), "UTF-16BE");
            } catch (java.io.UnsupportedEncodingException e) {
                throw new SqlException(agent_.logWriter_, "UnsupportedEncodingException: " + e.getMessage());
            }
        case java.sql.Types.VARBINARY:
        case java.sql.Types.LONGVARBINARY:
            try {
                return new java.io.InputStreamReader(new java.io.ByteArrayInputStream(get_VARCHAR_FOR_BIT_DATA(column)), "UTF-16BE");
            } catch (java.io.UnsupportedEncodingException e) {
                throw new SqlException(agent_.logWriter_, "UnsupportedEncodingException: " + e.getMessage());
            }
        case java.sql.Types.BLOB:
            try {
                Blob b = (Blob) getBlobColumn_(column, agent_);
                return new java.io.InputStreamReader(b.getBinaryStream(), "UTF-16BE");
            } catch (java.io.UnsupportedEncodingException e) {
                throw new SqlException(agent_.logWriter_, "UnsupportedEncodingException: " + e.getMessage());
            }
        default:
            throw new ColumnTypeConversionException(agent_.logWriter_);
        }
    }

    public final java.sql.Blob getBlob(int column) throws SqlException {
        switch (jdbcTypes_[column - 1]) {
        case Types.BLOB:
            return getBlobColumn_(column, agent_);
        default:
            throw new ColumnTypeConversionException(agent_.logWriter_);
        }
    }

    public final java.sql.Clob getClob(int column) throws SqlException {
        switch (jdbcTypes_[column - 1]) {
        case Types.CLOB:
            return getClobColumn_(column, agent_);
        default:
            throw new ColumnTypeConversionException(agent_.logWriter_);
        }
    }

    public final java.sql.Array getArray(int column) throws SqlException {
        throw new SqlException(agent_.logWriter_, "not yet implemented");
    }

    public final java.sql.Ref getRef(int column) throws SqlException {
        throw new SqlException(agent_.logWriter_, "not yet implemented");
    }

    public final Object getObject(int column) throws SqlException {
        switch (jdbcTypes_[column - 1]) {
        case java.sql.Types.SMALLINT:
            return new Integer(get_SMALLINT(column)); // See Table 4 in JDBC 1 spec (pg. 932 in jdbc book)
        case java.sql.Types.INTEGER:
            return new Integer(get_INTEGER(column));
        case java.sql.Types.BIGINT:
            return new Long(get_BIGINT(column));
        case java.sql.Types.REAL:
            return new Float(get_FLOAT(column));
        case java.sql.Types.DOUBLE:
            return new Double(get_DOUBLE(column));
        case java.sql.Types.DECIMAL:
            return get_DECIMAL(column);
        case java.sql.Types.DATE:
            return getDATE(column);
        case java.sql.Types.TIME:
            return getTIME(column);
        case java.sql.Types.TIMESTAMP:
            return getTIMESTAMP(column);
        case java.sql.Types.CHAR:
            return getCHAR(column);
        case java.sql.Types.VARCHAR:
        case java.sql.Types.LONGVARCHAR:
            return getVARCHAR(column);
        case Types.BINARY:
            return get_CHAR_FOR_BIT_DATA(column);
        case java.sql.Types.VARBINARY:
        case java.sql.Types.LONGVARBINARY:
            return get_VARCHAR_FOR_BIT_DATA(column);
        case java.sql.Types.BLOB:
            return getBlobColumn_(column, agent_);
        case java.sql.Types.CLOB:
            return getClobColumn_(column, agent_);
        default:
            throw new ColumnTypeConversionException(agent_.logWriter_);
        }
    }

    public final void allocateCharBuffer() {
        // compute the maximum char length
        int maxCharLength = 0;
        for (int i = 0; i < columns_; i++) {
            switch (jdbcTypes_[i]) {
            case Types.CHAR:
            case Types.VARCHAR:
            case Types.LONGVARCHAR:
                if (fdocaLength_[i] > maxCharLength) {
                    maxCharLength = fdocaLength_[i];
                }
            }
        }

        // allocate char buffer to accomodate largest result column
        charBuffer_ = new char[maxCharLength];
    }

    private final String getStringWithoutConvert(int position, int actualLength) throws SqlException {
        int start = position;
        int end = position + actualLength;

        int charCount = 0;
        while (start < end) {
            charBuffer_[charCount++] = (char) (((dataBuffer_[start] & 0xff) << 8) | (dataBuffer_[start + 1] & 0xff));
            start += 2;
        }

        return new String(charBuffer_, 0, charCount);
    }

    public void nullDataForGC() {
        dataBuffer_ = null;
        dataBufferStream_ = null;
        columnDataPosition_ = null;
        columnDataComputedLength_ = null;
        columnDataPositionCache_ = null;
        columnDataLengthCache_ = null;
        columnDataIsNullCache_ = null;
        jdbcTypes_ = null;
        nullable_ = null;
        charsetName_ = null;
        this.ccsid_ = null;
        isUpdateDeleteHoleCache_ = null;
        isNull_ = null;
        fdocaLength_ = null;
        charBuffer_ = null;
    }

    private final int getColumnPrecision(int column) {
        return ((fdocaLength_[column] >> 8) & 0xff);
    }

    private final int getColumnScale(int column) {
        return (fdocaLength_[column] & 0xff);
    }

    // Only used by Sqlca.getMessage() when using a locale encoding
    // to convert errror message text instead of relying on server encoding as usual.
    final byte[] getBytesFromVARCHAR(int column) throws SqlException {
        byte[] bytes;
        bytes = new byte[columnDataComputedLength_[column - 1] - 2];
        System.arraycopy(dataBuffer_, columnDataPosition_[column - 1] + 2, bytes, 0, bytes.length);
        return bytes;
    }
}