abstractresultset.java

Java写的TDS协议(JDBC/ODBC)实现

    public Object getObject(int i, java.util.Map map) throws SQLException
    {
        throw new java.lang.UnsupportedOperationException("Not Implemented");
    }

    public Ref getRef(int i) throws SQLException
    {
        throw new java.lang.UnsupportedOperationException("Not Implemented");
    }

    public Blob getBlob(int i) throws SQLException
    {
        throw new java.lang.UnsupportedOperationException("Not Implemented");
    }

    public Clob getClob(int i) throws SQLException
    {
        throw new java.lang.UnsupportedOperationException("Not Implemented");
    }

    public Array getArray(int i) throws SQLException
    {
        throw new java.lang.UnsupportedOperationException("Not Implemented");
    }

    public java.sql.Timestamp getTimestamp(int index, Calendar cal)
             throws SQLException
    {
        throw new java.lang.UnsupportedOperationException("Not Implemented");
    }

    public java.sql.Date getDate(int index, Calendar cal) throws SQLException
    {
        throw new java.lang.UnsupportedOperationException("Not Implemented");
    }

    public java.sql.Time getTime(int index, Calendar cal)
             throws SQLException
    {
        throw new java.lang.UnsupportedOperationException("Not Implemented");
    }

    public java.sql.Timestamp getTimestamp(int index) throws SQLException
    {
        return currentRow().getTimestamp(index);
    }

    public java.io.InputStream getUnicodeStream(int index) throws SQLException
    {
        String val = getString(index);
        if( val == null )
            return null;

        try
        {
            return new ByteArrayInputStream(val.getBytes("UTF-8"));
        }
        catch( UnsupportedEncodingException e )
        {
            // plain impossible with UTF-8
            return null;
        }
    }

    public int findColumn(String columnName) throws SQLException
    {
        int i;
        Columns info = getContext().getColumnInfo();

        for( i=1; i<=info.fakeColumnCount(); i++ )
            /** @todo Also need to look at the fully qualified name, i.e. table.column */
            if( info.getName(i).equalsIgnoreCase(columnName) )
                return i;

        throw new SQLException("No such column " + columnName);
    }

    public void updateNull(int index) throws SQLException
    {
        updateObject(index, null);
    }

    public void updateNull(String columnName) throws SQLException
    {
        updateNull(findColumn(columnName));
    }

    public void updateBoolean(String columnName, boolean x) throws SQLException
    {
        updateBoolean(findColumn(columnName), x);
    }

    public void updateByte(String columnName, byte x) throws SQLException
    {
        updateByte(findColumn(columnName), x);
    }

    public void updateShort(String columnName, short x) throws SQLException
    {
        updateShort(findColumn(columnName), x);
    }

    public void updateInt(String columnName, int x) throws SQLException
    {
        updateInt(findColumn(columnName), x);
    }

    public void updateLong(String columnName, long x) throws SQLException
    {
        updateLong(findColumn(columnName), x);
    }

    public void updateFloat(String columnName, float x) throws SQLException
    {
        updateFloat(findColumn(columnName), x);
    }

    public void updateDouble(String columnName, double x) throws SQLException
    {
        updateDouble(findColumn(columnName), x);
    }

    public void updateBigDecimal(String columnName, BigDecimal x) throws SQLException
    {
        updateBigDecimal(findColumn(columnName), x);
    }

    public void updateString(String columnName, String x) throws SQLException
    {
        updateString(findColumn(columnName), x);
    }

    public void updateBytes(String columnName, byte x[]) throws SQLException
    {
        updateBytes(findColumn(columnName), x);
    }

    public void updateDate(String columnName, java.sql.Date x) throws SQLException
    {
        updateDate(findColumn(columnName), x);
    }

    public void updateTime(String columnName, java.sql.Time x) throws SQLException
    {
        updateTime(findColumn(columnName), x);
    }

    public void updateTimestamp(String columnName, java.sql.Timestamp x) throws SQLException
    {
        updateTimestamp(findColumn(columnName), x);
    }

    public void updateAsciiStream(String columnName, java.io.InputStream x, int length)
        throws SQLException
    {
        updateAsciiStream(findColumn(columnName), x, length);
    }

    public void updateBinaryStream(String columnName, java.io.InputStream x, int length)
        throws SQLException
    {
        updateBinaryStream(findColumn(columnName), x, length);
    }

    public void updateCharacterStream(String columnName, java.io.Reader reader, int length)
        throws SQLException
    {
        updateCharacterStream(findColumn(columnName), reader, length);
    }

    public void updateObject(String columnName, Object x, int scale) throws SQLException
    {
        updateObject(findColumn(columnName), x, scale);
    }

    public void updateObject(String columnName, Object x) throws SQLException
    {
        updateObject(findColumn(columnName), x);
    }

    public boolean wasNull() throws SQLException
    {
        return currentRow().wasNull();
    }

    public void updateBoolean(int index, boolean x) throws SQLException
    {
        updateObject(index, new Boolean(x));
    }

    public void updateByte(int index, byte x) throws SQLException
    {
        updateObject(index, new Byte(x));
    }

    public void updateShort(int index, short x) throws SQLException
    {
        updateObject(index, new Short(x));
    }

    public void updateInt(int index, int x) throws SQLException
    {
        updateObject(index, new Integer(x));
    }

    public void updateLong(int index, long x) throws SQLException
    {
        updateObject(index, new Long(x));
    }

    public void updateFloat(int index, float x) throws SQLException
    {
        updateObject(index, new Float(x));
    }

    public void updateDouble(int index, double x) throws SQLException
    {
        updateObject(index, new Double(x));
    }

    public void updateBigDecimal(int index, BigDecimal x) throws SQLException
    {
        updateObject(index, x);
    }

    public void updateString(int index, String x) throws SQLException
    {
        updateObject(index, x);
    }

    public void updateBytes(int index, byte x[]) throws SQLException
    {
        updateObject(index, x);
    }

    public void updateDate(int index, java.sql.Date x) throws SQLException
    {
        updateObject(index, x);
    }

    public void updateTime(int index, java.sql.Time x) throws SQLException
    {
        updateObject(index, x);
    }

    public void updateTimestamp(int index, java.sql.Timestamp x) throws SQLException
    {
        updateObject(index, x);
    }

    public void updateAsciiStream(int index, java.io.InputStream x, int length) throws SQLException
    {
        throw new SQLException("Not Implemented");
    }

    public void updateBinaryStream(int index, java.io.InputStream x, int length) throws SQLException
    {
        throw new SQLException("Not Implemented");
    }

    public void updateCharacterStream(int index, java.io.Reader x, int length) throws SQLException
    {
        throw new SQLException("Not Implemented");
    }

    public void updateObject(int index, Object x, int scale) throws SQLException
    {
        if( x instanceof BigDecimal )
        {
            f.setMaximumFractionDigits(scale);
            updateObject(index, ((BigDecimal)x).setScale(scale));
        }
        else if( x instanceof Number )
        {
            f.setMaximumFractionDigits(scale);
            updateObject(index, f.format(x));
        }
        else
            updateObject( index, x );
    }

    public void updateObject(int index, Object x) throws SQLException
    {
        currentRow().setElementAt( index, x );
    }

    public void updateRef(int param, java.sql.Ref ref) throws java.sql.SQLException
    {
        throw new SQLException("Not Implemented");
    }

    public void updateRef(String columnName, java.sql.Ref ref) throws java.sql.SQLException
    {
        updateRef(findColumn(columnName), ref);
    }

    public void updateClob(int param, java.sql.Clob clob) throws java.sql.SQLException
    {
        throw new SQLException("Not Implemented");
    }

    public void updateClob(String columnName, java.sql.Clob clob) throws java.sql.SQLException
    {
        updateClob(findColumn(columnName), clob);
    }

    public void updateBlob(String columnName, java.sql.Blob blob) throws java.sql.SQLException
    {
        updateBlob(findColumn(columnName), blob);
    }

    public void updateBlob(int param, java.sql.Blob blob) throws java.sql.SQLException
    {
        throw new SQLException("Not Implemented");
    }

    public void updateArray(String columnName, java.sql.Array array) throws java.sql.SQLException
    {
        updateArray(findColumn(columnName), array);
    }

    public void updateArray(int param, java.sql.Array array) throws java.sql.SQLException
    {
        throw new SQLException("Not Implemented");
    }

    public java.net.URL getURL(String columnName) throws java.sql.SQLException
    {
        return getURL(findColumn(columnName));
    }

    public java.net.URL getURL(int param) throws java.sql.SQLException
    {
        throw new SQLException("Not Implemented");
    }
}