---

DTOResultSet.java

Go to the documentation of this file.

package net.threebit.utils.sosc;

/*
        Copyright 2003 Shawn Deleurme
        Copyright 2003 Kevin O'Donnell

        This program is free software; you can redistribute it and/or modify
        it under the terms of the GNU General public License as published by
        the Free Software Foundation; either version 2 of the License, or
        (at your option) any later version.

        This program is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU General public License for more details.

        You should have received a copy of the GNU General public License
        along with this program; if not, write to the Free Software
        Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

import java.io.*;
import java.sql.*;
import java.util.*;
import java.math.BigDecimal;
import java.util.Calendar;

public class DTOResultSet implements ResultSet,Serializable {

        private ArrayList rows = new ArrayList(100);

        private ArrayList columnNames = new ArrayList();

        private int cursor = 0;

        private ArrayList row = null;

        private ArrayList insertRow = null;

        boolean inserting = false;

        boolean lastGetColWasNull = false;

        DTOResultSetMetaData md = null;

        int[] types = new int[1024];

        public DTOResultSet(ResultSet r) throws SQLException {

                // Collect what we need from the metadata
                ResultSetMetaData md = r.getMetaData();
                int columnCount = md.getColumnCount();
                String[] columnNames = new String[ columnCount ];
                int[] columnTypes = new int[ columnCount ];
                for (int i=1; i <= columnCount; i++) {
                        columnNames[i-1] = md.getColumnName(i);
                        columnTypes[i-1] = md.getColumnType(i);
                }

                // If there is no current row then assume the caller 
                // wanted us to start the the beginning.
                if (r.getRow() == 0) { r.first(); }

                // Position the DTO to insert.
                moveToInsertRow();

                // Copy all of the rows.
                while (r.getRow() != 0) {
                        for (int i=1; i <= columnCount; i++) {
                                if (columnTypes[i-1] == Types.VARCHAR) { updateString(columnNames[i-1], r.getString(i)); }
                                else if (columnTypes[i-1] == Types.BOOLEAN) { updateBoolean(columnNames[i-1], r.getBoolean(i)); }
                                else if (columnTypes[i-1] == Types.CHAR) { updateByte(columnNames[i-1], r.getByte(i)); }
                                else if (columnTypes[i-1] == Types.SMALLINT) { updateShort(columnNames[i-1], r.getShort(i)); }
                                else if (columnTypes[i-1] == Types.INTEGER) { updateInt(columnNames[i-1], r.getInt(i)); }
                                else if (columnTypes[i-1] == Types.BIGINT) { updateLong(columnNames[i-1], r.getLong(i)); }
                                else if (columnTypes[i-1] == Types.FLOAT) { updateFloat(columnNames[i-1], r.getFloat(i)); }
                                else if (columnTypes[i-1] == Types.DECIMAL) { updateDouble(columnNames[i-1], r.getDouble(i)); }
                                else if (columnTypes[i-1] == Types.DATE) { updateDate(columnNames[i-1], r.getDate(i)); }
                                else { updateObject(columnNames[i-1], r.getObject(i)); }
                        }
                        insertRow();
                        if (! r.next()) { break; } // no more rows.
                } 
                beforeFirst();
        }

        public DTOResultSet() throws SQLException {
        }

        public int rows() {
                return rows.size();
        }

        private void setCol (int index, Object value) throws SQLException {
                if (row == null) { throw new SQLException("Current row is null!"); }
                if (index < 0) { throw new SQLException("Invalid index number ("+index+")"); }
                while (row.size() < (index)) { row.add(null); }
                row.set((index-1),value);
        }

        private Object getCol (int index) throws SQLException {
                // Convert from SQL index
                index--;
                if (row == null) { throw new SQLException("Current row is null!"); }
                if (index < 0 || index >= row.size()) { throw new SQLException("Invalid index number ("+index+"); row.size(): " + row.size()); }
                Object value = row.get(index);
                if (value == null) { lastGetColWasNull = true; }
                else { lastGetColWasNull = false; }
                return value;
        }

        private int indexOf (String column) throws SQLException {
                int index = columnNames.indexOf(column);
                if (index == -1) {
                        columnNames.add(column);
                        index = columnNames.indexOf(column);
                        // Assertion.
                        if (index == -1) { throw new SQLException("Added column name but still can't find it!"); }
                }
                // SQL indexing starts at 1
                return index+1;
        }

        // Methods from java.sql.ResultSet

        public void close() throws SQLException {
                rows = null;
                columnNames = null;
                cursor = 0;
                row = null;
                insertRow = null;
        }

        public boolean wasNull() throws SQLException {
                return lastGetColWasNull;
        }

        public ResultSetMetaData getMetaData() throws SQLException {
                if (md == null) { md = new DTOResultSetMetaData(); }
                return md;
        }

        public int findColumn(String columnName) throws SQLException {
                int index = columnNames.indexOf(columnName);
                if (index == -1) {
                        throw new SQLException("The column name '" + columnName + "' does not exist in the resultset.");
                }
                return index + 1;

        }

        // GETTER METHODS

        public String getString(int columnIndex) throws SQLException { 
                Object o = getCol(columnIndex);
                if (o == null) { return null; }
                if (o instanceof String) return (String) o;
                return o.toString();
        }

        public boolean getBoolean(int columnIndex) throws SQLException { 
                Object o = getCol(columnIndex);
                if (o == null) { return false; }
                if (o instanceof Boolean) return ((Boolean) o).booleanValue();
                try { return new Boolean(o.toString()).booleanValue(); } catch (Exception e) { throw new SQLException("Error converting '"+o+"'"); }
        }

        public byte getByte(int columnIndex) throws SQLException { 
                Object o = getCol(columnIndex);
                if (o == null) { return 0; }
                if (o instanceof Number) return ((Number) o).byteValue();
                try { return new Byte(o.toString()).byteValue(); } catch (Exception e) { throw new SQLException("Error converting '"+o+"'"); }
        }

        public short getShort(int columnIndex) throws SQLException { 
                Object o = getCol(columnIndex);
                if (o == null) { return 0; }
                if (o instanceof Number) return ((Number) o).shortValue();
                try { return new Short(o.toString()).shortValue(); } catch (Exception e) { throw new SQLException("Error converting '"+o+"'"); }
        }

        public int getInt(int columnIndex) throws SQLException { 
                Object o = getCol(columnIndex);
                if (o == null) { return 0; }
                if (o instanceof Number) return ((Number) o).intValue();
                try { return new Integer(o.toString()).intValue(); } catch (Exception e) { throw new SQLException("Error converting '"+o+"'"); }
        }

        public long getLong(int columnIndex) throws SQLException { 
                Object o = getCol(columnIndex);
                if (o == null) { return 0; }
                if (o instanceof Number) return ((Number) o).longValue();
                try { return new Long(o.toString()).longValue(); } catch (Exception e) { throw new SQLException("Error converting '"+o+"'"); }
        }

        public float getFloat(int columnIndex) throws SQLException { 
                Object o = getCol(columnIndex);
                if (o == null) { return 0; }
                if (o instanceof Number) return ((Number) o).floatValue();
                try { return new Float(o.toString()).floatValue(); } catch (Exception e) { throw new SQLException("Error converting '"+o+"'"); }
        }

        public double getDouble(int columnIndex) throws SQLException { 
                Object o = getCol(columnIndex);
                if (o == null) { return 0; }
                if (o instanceof Number) return ((Number) o).doubleValue();
                try { return new Double(o.toString()).doubleValue(); } catch (Exception e) { throw new SQLException("Error converting '"+o+"'"); }
        }

        public java.sql.Date getDate(int columnIndex) throws SQLException { 
                Object o = getCol(columnIndex);
                if (o == null) { return null; }
                if (o instanceof java.sql.Date) return (java.sql.Date) getCol( columnIndex ); 
                throw new SQLException("Cannot convert to java.sql.Date");
        }

        public String getString(String columnName) throws SQLException { 
                return getString(indexOf(columnName));
        }

        public boolean getBoolean(String columnName) throws SQLException { 
                return getBoolean(indexOf(columnName));
        }

        public byte getByte(String columnName) throws SQLException { 
                return getByte(indexOf(columnName));
        }

        public short getShort(String columnName) throws SQLException { 
                return getShort(indexOf(columnName));
        }

        public int getInt(String columnName) throws SQLException { 
                return getInt(indexOf(columnName));
        }

        public long getLong(String columnName) throws SQLException { 
                return getLong(indexOf(columnName));
        }

        public float getFloat(String columnName) throws SQLException { 
                return getFloat(indexOf(columnName));
        }

        public double getDouble(String columnName) throws SQLException { 
                return getDouble(indexOf(columnName));
        }

        public java.sql.Date getDate(String columnName) throws SQLException { 
                return getDate(indexOf(columnName));
        }

        public Object getObject(int columnIndex) throws SQLException { 
                return getCol(columnIndex);
        }

        public Object getObject(String columnName) throws SQLException { 
                return getObject(indexOf(columnName));
        }

        // [END] GETTER METHODS

        public boolean isBeforeFirst() throws SQLException {
                if (cursor <= -1) { return true; }
                return false;
        }

        public boolean isAfterLast() throws SQLException {
                if (cursor >= rows.size()) { return true; }
                return false;
        }

        public boolean isFirst() throws SQLException {
                if (cursor == 0) { return true; }
                return false;
        }

        public boolean isLast() throws SQLException {
                if (cursor == (rows.size()-1)) { return true; }
                return false;
        }

        public void beforeFirst() throws SQLException {
                cursor = -1;
                row = null;
        }

        public void afterLast() throws SQLException {
                cursor = rows.size();
                row = null;
        }

        public boolean first() throws SQLException {
                return absolute(1);

        }

        public boolean last() throws SQLException {
                return absolute(rows.size());
        }

        public int getRow() throws SQLException {
                if (cursor < 0) {
                        beforeFirst();
                        return 0;
                }
                if (cursor >= rows.size()) {
                        afterLast();
                        return 0;
                }
                // Convert to SQL indexing
                return cursor+1;
        }

        public boolean absolute( int row ) throws SQLException {
                // If negative, go recursive one level.
                if (row < 0) {
                        row = row * -1;
                        return absolute( rows.size() + row );
                }

                // Convert from SQL index.
                row--;

                // Update the cursor
                cursor = row;

                // Fix any first/last overflows
                if (getRow() == 0) {
                        this.row = null;
                        return false;
                }

                this.row = (ArrayList) rows.get(cursor);
                return true;
        }

        public boolean relative( int rows ) throws SQLException {
                if (rows >= 0) {
                        return absolute( getRow() + rows );
                }
                if (rows < 0) {
                        return absolute( getRow() - rows );
                }
                throw new RuntimeException("only NAN will cause this.");
        }

        public boolean next() throws SQLException {
                return relative(1);
        }

        public boolean previous() throws SQLException {
                return relative(-1);
        }

        public void setFetchDirection(int direction) throws SQLException { }

        public int getFetchDirection() throws SQLException { return FETCH_FORWARD; }

        public void setFetchSize(int rows) throws SQLException { }

        public int getFetchSize() throws SQLException { return 1; }

        public int getType() throws SQLException { return TYPE_SCROLL_INSENSITIVE; }

        public int getConcurrency() throws SQLException { return CONCUR_UPDATABLE; }

        public boolean rowUpdated() throws SQLException { return false; }

        public boolean rowInserted() throws SQLException { return false; }

        public boolean rowDeleted() throws SQLException { return false; }

        // Updater METHODS

        public void updateNull(int columnIndex) throws SQLException { setCol( columnIndex, null); }

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

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

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

        public void updateInt(int columnIndex, int x) throws SQLException { setCol( columnIndex, new Integer(x)); }

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

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

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

        public void updateBigDecimal(int columnIndex, BigDecimal x) throws SQLException { setCol( columnIndex, x); }

        public void updateString(int columnIndex, String x) throws SQLException { setCol( columnIndex, x); }

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

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

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

        public void updateObject(int columnIndex, Object x) throws SQLException { setCol( columnIndex, x); }

        public void updateNull(String columnName) throws SQLException { setCol( indexOf(columnName), null); }

        public void updateBoolean(String columnName, boolean x) throws SQLException { setCol( indexOf(columnName), null); }

        public void updateByte(String columnName, byte x) throws SQLException { setCol( indexOf(columnName), new Byte(x)); }

        public void updateShort(String columnName, short x) throws SQLException { setCol(indexOf(columnName),new Short(x)); }

        public void updateInt(String columnName, int x) throws SQLException { setCol(indexOf(columnName),new Integer(x)); }

        public void updateLong(String columnName, long x) throws SQLException { setCol(indexOf(columnName),new Long(x)); }

        public void updateFloat(String columnName, float x) throws SQLException { setCol(indexOf(columnName),new Float(x)); }

        public void updateDouble(String columnName, double x) throws SQLException { setCol(indexOf(columnName),new Double(x)); }

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

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

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

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

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

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

        // [END] Updater METHODS

        public void insertRow() throws SQLException {

                // Add the row
                rows.add(insertRow);

                // Flag as not inserting
                inserting = false;

                // And redo the "start to insert logic"
                moveToInsertRow();

        }

        public void updateRow() throws SQLException {
        }

        public void deleteRow() throws SQLException {
                if (getRow() == 0) { throw new SQLException("Not on a valid row."); }
                // Delete the current row
                rows.remove(cursor);
                // Update state of the same cursor point.
                absolute(cursor);
        }

        public void refreshRow() throws SQLException {
                if (inserting) { throw new SQLException("Cannot refresh the insert row."); }
        }

        public void cancelRowUpdates() throws SQLException { throw new SQLException("This should really be implemented. Implemented"); }

        public void moveToInsertRow() throws SQLException {
                if (inserting) {
                        // Already inserting
                        row = insertRow;
                }
                else {
                        inserting = true;
                        insertRow = new ArrayList();
                        row = insertRow;
                }
        }

        public void moveToCurrentRow() throws SQLException {

                row = (ArrayList) rows.get(cursor);

        }


        // Will probably never be implemented.

        public Statement getStatement() throws SQLException { throw new SQLException("Not Implemented Yet"); }

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

        public void updateRef(String columnName, java.sql.Ref x) throws SQLException { throw new SQLException("Not Implemented Yet"); }

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

        public void updateBlob(String columnName, java.sql.Blob x) throws SQLException { throw new SQLException("Not Implemented Yet"); }

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

        public void updateClob(String columnName, java.sql.Clob x) throws SQLException { throw new SQLException("Not Implemented Yet"); }

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

        public void updateArray(String columnName, java.sql.Array x) throws SQLException { throw new SQLException("Not Implemented Yet"); }

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

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

        public void updateCharacterStream(String columnName, java.io.Reader reader, int length) throws SQLException { throw new SQLException("Not Implemented Yet"); }

        public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException { throw new SQLException("Not Implemented Yet"); }

        public byte[] getBytes(int columnIndex) throws SQLException { throw new SQLException("Not Implemented Yet"); }

        public java.sql.Time getTime(int columnIndex) throws SQLException { throw new SQLException("Not Implemented Yet"); }

        public java.sql.Timestamp getTimestamp(int columnIndex) throws SQLException { throw new SQLException("Not Implemented Yet"); }

        public java.io.InputStream getAsciiStream(int columnIndex) throws SQLException { throw new SQLException("Not Implemented Yet"); }

        public java.io.InputStream getUnicodeStream(int columnIndex) throws SQLException { throw new SQLException("Not Implemented Yet"); }

        public java.io.InputStream getBinaryStream(int columnIndex) throws SQLException { throw new SQLException("Not Implemented Yet"); }

        public BigDecimal getBigDecimal(String columnName, int scale) throws SQLException { throw new SQLException("Not Implemented Yet"); }

        public byte[] getBytes(String columnName) throws SQLException { throw new SQLException("Not Implemented Yet"); }

        public java.sql.Time getTime(String columnName) throws SQLException { throw new SQLException("Not Implemented Yet"); }

        public java.sql.Timestamp getTimestamp(String columnName) throws SQLException { throw new SQLException("Not Implemented Yet"); }

        public java.io.InputStream getAsciiStream(String columnName) throws SQLException { throw new SQLException("Not Implemented Yet"); }

        public java.io.InputStream getUnicodeStream(String columnName) throws SQLException { throw new SQLException("Not Implemented Yet"); }

        public java.io.InputStream getBinaryStream(String columnName) throws SQLException { throw new SQLException("Not Implemented Yet"); }

        public SQLWarning getWarnings() throws SQLException { throw new SQLException("Not Implemented Yet"); }

        public void clearWarnings() throws SQLException { throw new SQLException("Not Implemented Yet"); }

        public String getCursorName() throws SQLException { throw new SQLException("Not Implemented Yet"); }

        public java.io.Reader getCharacterStream(int columnIndex) throws SQLException { throw new SQLException("Not Implemented Yet"); }

        public java.io.Reader getCharacterStream(String columnName) throws SQLException { throw new SQLException("Not Implemented Yet"); }

        public BigDecimal getBigDecimal(int columnIndex) throws SQLException { throw new SQLException("Not Implemented Yet"); }

        public BigDecimal getBigDecimal(String columnName) throws SQLException { throw new SQLException("Not Implemented Yet"); }

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

        public Ref getRef(int i) throws SQLException { throw new SQLException("Not Implemented Yet"); }

        public Blob getBlob(int i) throws SQLException { throw new SQLException("Not Implemented Yet"); }

        public Clob getClob(int i) throws SQLException { throw new SQLException("Not Implemented Yet"); }

        public Array getArray(int i) throws SQLException { throw new SQLException("Not Implemented Yet"); }

        public Object getObject(String colName, java.util.Map map) throws SQLException { throw new SQLException("Not Implemented Yet"); }

        public Ref getRef(String colName) throws SQLException { throw new SQLException("Not Implemented Yet"); }

        public Blob getBlob(String colName) throws SQLException { throw new SQLException("Not Implemented Yet"); }

        public Clob getClob(String colName) throws SQLException { throw new SQLException("Not Implemented Yet"); }

        public Array getArray(String colName) throws SQLException { throw new SQLException("Not Implemented Yet"); }

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

        public java.sql.Date getDate(String columnName, Calendar cal) throws SQLException { throw new SQLException("Not Implemented Yet"); }

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

        public java.sql.Time getTime(String columnName, Calendar cal) throws SQLException { throw new SQLException("Not Implemented Yet"); }

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

        public java.sql.Timestamp getTimestamp(String columnName, Calendar cal) throws SQLException { throw new SQLException("Not Implemented Yet"); }

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

        public java.net.URL getURL(String columnName) throws SQLException { throw new SQLException("Not Implemented Yet"); }

        public void updateObject(String columnName, Object x, int scale) throws SQLException { throw new SQLException("Not Implemented Yet"); }

        public void updateBytes(int columnIndex, byte x[]) throws SQLException { throw new SQLException("Not Implemented Yet"); }

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

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

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

        public void updateObject(int columnIndex, Object x, int scale) throws SQLException { throw new SQLException("Not Implemented Yet"); }

        public void updateBytes(String columnName, byte x[]) throws SQLException { throw new SQLException("Not Implemented Yet"); }

        public String toString() {
                if (columnNames == null || rows == null) { return getClass().getName() + ":empty"; }

                StringBuffer sb = new StringBuffer();
                sb.append( getClass().getName() );
                sb.append(": ");
                for (int c = 0; c < columnNames.size(); c++) {
                        sb.append( columnNames.get(c) );
                        sb.append(",");
                }
                sb.deleteCharAt( sb.length()-1 ); 
                sb.append("\n");
                for (int r = 0; r < rows.size(); r++) {
                        List row = (List) rows.get(r);
                        sb.append(r + ": ");
                        for (int c = 0; c < row.size(); c++) {
                                sb.append( row.get(c) );
                                sb.append(", ");
                        }
                        if (row.size() > 0) { sb.deleteCharAt( sb.length()-1 ); }
                        sb.append("\n");
                }
                return sb.toString();
        }

        public class DTOResultSetMetaData implements ResultSetMetaData {

    public int getColumnType(int column) throws SQLException {

                        // search through the result set until we find a non-null entry for the
                        // requested column; when we do return the appropriate type.
                        for (int x = 0; x < DTOResultSet.this.rows.size(); x++) {

                                ArrayList row = (ArrayList) DTOResultSet.this.rows.get(x);
                                Object o = row.get(column-1);

                                // Keep looking for a real value.
                                if (o == null) { continue; }
                                if (o instanceof String) { return Types.VARCHAR; }
                                if (o instanceof Boolean) { return Types.BOOLEAN; }
                                if (o instanceof Byte) { return Types.CHAR; }
                                if (o instanceof Short) { return Types.SMALLINT; }
                                if (o instanceof Integer) { return Types.INTEGER; }
                                if (o instanceof Long) { return Types.BIGINT; }
                                if (o instanceof Float) { return Types.FLOAT; }
                                if (o instanceof Double) { return Types.DECIMAL; }
                                if (o instanceof java.sql.Date) { return Types.DATE; }
                                return Types.OTHER;
                        }
                        // Assume NULL
                        return Types.NULL;
                }

    public String getColumnTypeName(int column) throws SQLException {
                        return "DTOResultSetColumn";
                }

    public int getColumnCount() throws SQLException {
                        if (DTOResultSet.this.columnNames == null) { throw new SQLException("No column names defined"); }
                        return DTOResultSet.this.columnNames.size();
                }

    public boolean isAutoIncrement(int column) throws SQLException { return false; }

    public boolean isCaseSensitive(int column) throws SQLException { return true; }

    public boolean isSearchable(int column) throws SQLException { return true; }

    public boolean isCurrency(int column) throws SQLException { return false; }

    public int isNullable(int column) throws SQLException { return columnNullable; }

    public boolean isSigned(int column) throws SQLException { return true; }

    public int getColumnDisplaySize(int column) throws SQLException { return 12; }

    public String getColumnLabel(int column) throws SQLException {
                        if (DTOResultSet.this.columnNames == null) { throw new SQLException("No column names defined"); }
                        return (String) DTOResultSet.this.columnNames.get(column-1);
                }

    public String getColumnName(int column) throws SQLException {
                        if (DTOResultSet.this.columnNames == null) { throw new SQLException("No column names defined"); }
                        return (String) DTOResultSet.this.columnNames.get(column-1);
                }

    public String getSchemaName(int column) throws SQLException { return "DTOResultSetSchema"; }

    public int getPrecision(int column) throws SQLException { return 2; }

    public int getScale(int column) throws SQLException { return 32; }

    public String getTableName(int column) throws SQLException { return "DTOTable"; }

    public String getCatalogName(int column) throws SQLException { return "DTOCatalog"; }

    public boolean isReadOnly(int column) throws SQLException { return false; }

    public boolean isWritable(int column) throws SQLException { return true; }

    public boolean isDefinitelyWritable(int column) throws SQLException { return true; }

    public String getColumnClassName(int column) throws SQLException { return "java.lang.Object"; }

        }

}

---