axionresultset.java

开源的axion的数据库代码

    }

    public Date getDate(String colName) throws SQLException {
        return getDate(getResultSetIndexForColumnName(colName));
    }

    public Date getDate(int i, Calendar cal) throws SQLException {
        throw new UnsupportedOperationException();
    }

    public Date getDate(String colName, Calendar cal) throws SQLException {
        return getDate(getResultSetIndexForColumnName(colName),cal);
    }

    public double getDouble(int i) throws SQLException {
        Object value = getValue(i);
        if(null == value) {
            return NULL_DOUBLE;
        } else {
            return getDataType(i).toDouble(value);
        }
    }

    public double getDouble(String colName) throws SQLException {
        return getDouble(getResultSetIndexForColumnName(colName));
    }

    public int getFetchDirection() throws SQLException {
        throw new UnsupportedOperationException();
    }

    public int getFetchSize() throws SQLException {
        throw new UnsupportedOperationException();
    }

    public float getFloat(int i) throws SQLException {
        Object value = getValue(i);
        if(null == value) {
            return NULL_FLOAT;
        } else {
            return getDataType(i).toFloat(value);
        }
    }

    public float getFloat(String colName) throws SQLException {
        return getFloat(getResultSetIndexForColumnName(colName));
    }

    public int getInt(int i) throws SQLException {
        Object value = getValue(i);
        if(null == value) {
            return NULL_INT;
        } else {
            return getDataType(i).toInt(value);
        }
    }

    public int getInt(String colName) throws SQLException {
        return getInt(getResultSetIndexForColumnName(colName));
    }

    public long getLong(int i) throws SQLException {
        Object value = getValue(i);
        if(null == value) {
            return NULL_LONG;
        } else {
            return getDataType(i).toLong(value);
        }
    }

    public long getLong(String colName) throws SQLException {
        return getLong(getResultSetIndexForColumnName(colName));
    }

    public ResultSetMetaData getMetaData() throws SQLException {
        return _meta;
    }

    public Object getObject(int i) throws SQLException {
        return getValue(i);
    }

    public Object getObject(String colName) throws SQLException {
        return getObject(getResultSetIndexForColumnName(colName));
    }

    public Object getObject(int i, Map map) throws SQLException {
        throw new UnsupportedOperationException();
    }

    public Object getObject(String colName, Map map) throws SQLException {
        return getObject(getResultSetIndexForColumnName(colName),map);
    }

    public Ref getRef(int i) throws SQLException {
        throw new UnsupportedOperationException();
    }

    public Ref getRef(String colName) throws SQLException {
        return getRef(getResultSetIndexForColumnName(colName));
    }

    public int getRow() throws SQLException {
        try {
            return _currentRow.getRowIndex() + 1;
        } catch(AxionException e) {
            throw ExceptionConverter.convert(e);
        }
    }

    public short getShort(int i) throws SQLException {
        Object value = getValue(i);
        if(null == value) {
            return NULL_SHORT;
        } else {
            return getDataType(i).toShort(value);
        }
    }

    public short getShort(String colName) throws SQLException {
        return getShort(getResultSetIndexForColumnName(colName));
    }

    public Statement getStatement() throws SQLException {
        throw new UnsupportedOperationException();
    }

    public String getString(int i) throws SQLException {
        Object value = getValue(i);
        if(null == value) {
            return NULL_STRING;
        } else {
            return getDataType(i).toString(value);
        }
    }

    public String getString(String colName) throws SQLException {
        return getString(getResultSetIndexForColumnName(colName));
    }

    public Time getTime(int i) throws SQLException {
        Object value = getValue(i);
        if(null == value) {
            return NULL_TIME;
        } else {
            return getDataType(i).toTime(value);
        }
    }

    public Time getTime(String colName) throws SQLException {
        return getTime(getResultSetIndexForColumnName(colName));
    }

    public Time getTime(int i, Calendar cal) throws SQLException {
        throw new UnsupportedOperationException();
    }

    public Time getTime(String colName, Calendar cal) throws SQLException {
        return getTime(getResultSetIndexForColumnName(colName),cal);
    }

    public Timestamp getTimestamp(int i) throws SQLException {
        Object value = getValue(i);
        if(null == value) {
            return NULL_TIMESTAMP;
        } else {
            return getDataType(i).toTimestamp(value);
        }
    }

    public Timestamp getTimestamp(String colName) throws SQLException {
        return getTimestamp(getResultSetIndexForColumnName(colName));
    }

    public Timestamp getTimestamp(int i, Calendar cal) throws SQLException {
        throw new UnsupportedOperationException();
    }

    public Timestamp getTimestamp(String colName, Calendar cal) throws SQLException {
        return getTimestamp(getResultSetIndexForColumnName(colName),cal);
    }

    public int getType() throws SQLException {
        return ResultSet.TYPE_FORWARD_ONLY;
    }

    /** @deprecated See {@link java.sql.ResultSet#getUnicodeStream} */
    public InputStream getUnicodeStream(int i) throws SQLException {
        String val = getString(i);
        if(null == val) {
            return NULL_STREAM;
        } else {
            try {
                return new ByteArrayInputStream(val.getBytes("UnicodeBig"));
            } catch(UnsupportedEncodingException e) {
                throw ExceptionConverter.convert(e);
            }
        }
    }

    /** @deprecated See {@link java.sql.ResultSet#getUnicodeStream} */
    public InputStream getUnicodeStream(String colName) throws SQLException {
        return getUnicodeStream(getResultSetIndexForColumnName(colName));
    }

    public SQLWarning getWarnings() throws SQLException {
        return null;
    }

    public void insertRow() throws SQLException {
        throw new UnsupportedOperationException();
    }

    public boolean isAfterLast() throws SQLException {
        throw new UnsupportedOperationException();
    }

    public boolean isBeforeFirst() throws SQLException {
        return 0 == _currentRowIndex && _rows.hasNext();
    }

    public boolean isFirst() throws SQLException {
        return 1 == _currentRowIndex;
    }

    public boolean isLast() throws SQLException {
        throw new UnsupportedOperationException();
    }

    public boolean last() throws SQLException {
        throw new UnsupportedOperationException();
    }

    public void moveToCurrentRow() throws SQLException {
        throw new UnsupportedOperationException();
    }

    public void moveToInsertRow() throws SQLException {
        throw new UnsupportedOperationException();
    }

    public boolean next() throws SQLException {       
        assertOpen();
        if(_maxRows > 0 && _currentRowIndex >= _maxRows) {
            return false;
        }            
        boolean result = _rows.hasNext();
        if(result) {
            try {
                _currentRow = _rows.next();
            } catch(AxionException e) {
                throw ExceptionConverter.convert(e);
            }
            _currentRowIndex++;
        }
        return result;
    }

    public boolean previous() throws SQLException {
        throw new UnsupportedOperationException();
    }

    public void refreshRow() throws SQLException {
        throw new UnsupportedOperationException();
    }

    public boolean relative(int rows) throws SQLException {
        throw new UnsupportedOperationException();
    }

    public boolean rowDeleted() throws SQLException {
        throw new UnsupportedOperationException();
    }

    public boolean rowInserted() throws SQLException {
        throw new UnsupportedOperationException();
    }

    public boolean rowUpdated() throws SQLException {
        throw new UnsupportedOperationException();
    }

    public void setFetchDirection(int direction) throws SQLException {
        // fetchDirection is just a hint
    }

    public void setFetchSize(int size) throws SQLException {
        // fetch size is just a hint
    }

    public void updateAsciiStream(int i, InputStream in, int length) throws SQLException {
        throw new UnsupportedOperationException();
    }

    public void updateAsciiStream(String colName, InputStream in, int length) throws SQLException {
        updateAsciiStream(getResultSetIndexForColumnName(colName),in,length);
    }

    public void updateBigDecimal(int i, BigDecimal value) throws SQLException {
        throw new UnsupportedOperationException();
    }

    public void updateBigDecimal(String colName, BigDecimal value) throws SQLException {
        updateBigDecimal(getResultSetIndexForColumnName(colName),value);
    }

    public void updateBinaryStream(int i, InputStream value, int length) throws SQLException {
        throw new UnsupportedOperationException();
    }

    public void updateBinaryStream(String colName, InputStream value, int length) throws SQLException {
        updateBinaryStream(getResultSetIndexForColumnName(colName),value,length);
    }

    public void updateBoolean(int i, boolean value) throws SQLException {
        throw new UnsupportedOperationException();
    }