AntApache ConfigurationAppleScriptCC#C++Cold FusionDelphi PascalFlash ActionScriptHTML / CSSJSP / JSTL / JSFJavaJavascript / AjaxObjective-C CocoaPHPPerlPythonRuby / RailsSQLUnix / ShellXML-SchemaXSLT / XPATHDirector LingoLego MindstormsObjective-C SwarmPIC assembly   Whole Words   Literal Phrase       Examples

Source code below from: Java Cookbook, Second Edition By Ian Darwin Published 14 June, 2004 Average rating       Powells     Alibris

//----------------------------------------------------------------------------
//
// Module:      SimpleTextResultSet.java
//
// Description: Implementation of the JDBC ResultSet interface
//
// Author:      Karl Moss
//
// Copyright:   (C) 1996,1997 Karl Moss.  All rights reserved.
//              You may study, use, modify and distribute this example
//              for any purpose, provided that this copyright notice
//              appears in all copies.  This example is provided WITHOUT
//              WARRANTY either expressed or implied.
//----------------------------------------------------------------------------

package jdbc.SimpleText;

//----------------------------------------------------------------------------
// A ResultSet provides access to a table of data generated by
// executing a Statement. The table rows are retrieved in
// sequence. Within a row its column values can be accessed in any
// order.
//
// A ResultSet maintains a cursor pointing to its current row of
// data.  Initially the cursor is positioned before the first row.
// The 'next' method moves the cursor to the next row.
//
// The getXXX methods retrieve column values for the current
// row.  You can retrieve values either using the index number of the
// column, or by using the name of the column.  In general using the
// column index will be more efficient.  Columns are numbered from 1.
//
// For maximum portability, ResultSet columns within each row should be
// read in left-to-right order and each column should be read only once.
//
// For the getXXX methods, the JDBC driver attempts to convert the
// underlying data to the specified Java type and returns a suitable
// Java value.  See the JDBC specification for allowable mappings
// from SQL types to Java types with the ResultSet.getXXX methods.
//
// Column names used as input to getXXX methods are case insensitive.
// When performing a getXXX using a column name if several columns have
// the same name then the value of the first matching column will be
// returned.
//
// A ResultSet is automatically closed by the Statement that
// generated it when that Statement is closed, re-executed, or is used
// to retrieve the next result from a sequence of multiple results.
//
// The number, types and properties of a ResultSet's columns are
// provided by the ResulSetMetaData object returned by the getMetaData
// method.
//----------------------------------------------------------------------------
// NOTE - this is an implementation of the JDBC API version 1.20
//---------------------------------------------------------------------------

import java.sql.*;
import java.util.Hashtable;
import java.io.*;

public class SimpleTextResultSet
    extends        SimpleTextObject
    implements    ResultSet
{

    //------------------------------------------------------------------------
    // initialize
    //------------------------------------------------------------------------

    public void initialize(
        SimpleTextIStatement statement,
        String catalog,
        String table,
        Hashtable columns,
        SimpleTextFilter filter)
        throws SQLException
    {
        // Save the owning statement object

        ownerStatement = statement;
        ownerConnection = ownerStatement.getConnection();

        // Save the in-memory column definitions

        inMemoryColumns = columns;

        // Save the select WHERE filter

        selectFilter = filter;

        // If a table was given, open it now

        if (table != null) {
            openSDF(catalog, table);
        }
    }

    public void initialize(
        SimpleTextIStatement statement,
        Hashtable columns,
        Hashtable rows)
        throws SQLException
    {
        // Save the in-memory rows (used for catalog functions)

        inMemoryRows = rows;
        rowNum = 0;

        initialize(statement, null, null, columns, null);
    }

    //------------------------------------------------------------------------
    // next - JDBC API
    // A ResultSet is initially positioned before its first row; the
    // first call to next makes the first row the current row; the
    // second call makes the second row the current row, etc.
    //
    // If an input stream from the previous row is open it is
    // implicitly closed. The ResultSet's warning chain is cleared
    // when a new row is read.
    //
    // Returns true if the new current row is valid; false if there
    // are no more rows
    //------------------------------------------------------------------------

    public boolean next()
        throws SQLException
    {
        boolean rc = true;
        boolean validRow = false;

        // In memory result set, get the next row

        if (inMemoryRows != null) {
            rowNum++;

            // No more rows, return end-of-file

            if (rowNum > inMemoryRows.size()) {
                rc = false;
            }
        }
        else {

            // Not in-memory, read the next line from the file until a
            // valid row has been found

            while (!validRow) {

                currentLine = readLine(rafSDF);

                if (currentLine == null) {
                    rc = false;
                    break;
                }

                // We'll cheat a little bit here.  We'll use the SQL
                // parser to break the line up, then treat it as a
                // comma separated list (much like a select list)

                String data[] = ownerConnection.parseSQL(currentLine);

                Hashtable dataList = new Hashtable();

                ownerStatement.buildList(data, 0, "", dataList);

                // Now go through each data element and create a
                // CommonValue object.  Then, put the CommonValue object
                // on our columnValues list

                SimpleTextColumn column;
                columnValues = new Hashtable();
                String s;
                CommonValue value;

                for (int i = 1; i <= dataList.size(); i++) {
                    column = (SimpleTextColumn) dataList.get(new Integer(i));

                    // Get the data item

                    s = column.name;

                    // Remove any quotes
                    if (s.startsWith("'") &&
                        s.endsWith("'")) {
                        s = s.substring(1, s.length() - 1);
                    }

                    // Create a CommonValue object using the string

                    value = new CommonValue(s);

                    // Create a CommonValue object

                    columnValues.put(new Integer(i), value);

                }

                // Filter the row, if necessary

                validRow = filterRow(columnValues, selectFilter);

            }
        }
        return rc;
    }


    //------------------------------------------------------------------------
    // close - JDBC API
    // In some cases, it is desirable to immediately release a
    // ResultSet's database and JDBC resources instead of waiting for
    // this to happen when it is automatically closed; the close
    // method provides this immediate release.
    //
    // Note:  A ResultSet is automatically closed by the
    // Statement that generated it when that Statement is closed,
    // re-executed, or is used to retrieve the next result from a
    // sequence of multiple results. A ResultSet is also automatically
    // closed when it is garbage collected.
    //------------------------------------------------------------------------

    public void close()
        throws SQLException
    {
        try {
            if (rafSDF != null) {
                rafSDF.close();
            }
            if (rafSBF != null) {
                rafSBF.close();
            }
        }
        catch (Exception ex) {
        }
    }

    //------------------------------------------------------------------------
    // wasNull - JDBC API
    // A column may have the value of SQL NULL; wasNull reports whether
    // the last column read had this special value.
    // Note that you must first call getXXX on a column to try to read
    // its value and then call wasNull() to find if the value was
    // the SQL NULL.
    //
    // Returns true if last column read was SQL NULL
    //------------------------------------------------------------------------

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

    //------------------------------------------------------------------------
    // getString - JDBC API
    // Get the value of a column in the current row as a Java String.
    //
    //    columnIndex        the first column is 1, the second is 2, ...
    //
    // Returns the column value; if the value is SQL NULL the result is null
    //------------------------------------------------------------------------

    public String getString(
        int columnIndex)
        throws SQLException
    {

        // Verify the column

        verify(columnIndex);

        String s = null;

        if (inMemoryRows != null) {
            s = (getColumn(rowNum, columnIndex)).getString();
        }
        else {
            CommonValue value = getValue(columnIndex);

            if (value != null) {
                s = value.getString();
            }
        }

        if (s == null) {
            lastNull = true;
        }

        return s;
    }

    //------------------------------------------------------------------------
    // getBoolean - JDBC API
    // Get the value of a column in the current row as a Java boolean.
    //
    //    columnIndex        the first column is 1, the second is 2, ...
    //
    // Returns the column value; if the value is SQL NULL the result is false
    //------------------------------------------------------------------------

    public boolean getBoolean(
        int columnIndex)
        throws SQLException
    {
        // We could coerce the data, but for now an exception is thrown

        throw DataTypeNotSupported();
    }

    //------------------------------------------------------------------------
    // getByte - JDBC API
    // Get the value of a column in the current row as a Java byte.
    //
    //    columnIndex        the first column is 1, the second is 2, ...
    // Returns the column value; if the value is SQL NULL the result is 0
    //------------------------------------------------------------------------

    public byte getByte(
        int columnIndex)
        throws SQLException
    {
        // We could coerce the data, but for now an exception is thrown

        throw DataTypeNotSupported();
    }

    //------------------------------------------------------------------------
    // getShort - JDBC API
    // Get the value of a column in the current row as a Java short.
    //
    //    columnIndex        the first column is 1, the second is 2, ...
    //
    // Returns the column value; if the value is SQL NULL the result is 0
    //------------------------------------------------------------------------

    public short getShort(
        int columnIndex)
        throws SQLException
    {
        // We could coerce the data, but for now an exception is thrown

        throw DataTypeNotSupported();
    }

    //------------------------------------------------------------------------
    // getInt - JDBC API
    // Get the value of a column in the current row as a Java int.
    //
    //    columnIndex        the first column is 1, the second is 2, ...
    //
    // Returns the column value; if the value is SQL NULL the result is 0
    //------------------------------------------------------------------------

    public int getInt(
        int columnIndex)
        throws SQLException
    {
        // Verify the column

        verify(columnIndex);

        CommonValue value;

        if (inMemoryRows != null) {
            value = getColumn(rowNum, columnIndex);
        }
        else {
            value = getValue(columnIndex);
        }

        // Check for a null value

        if (value == null) {
            lastNull = true;
            return 0;
        }

        if (value.isNull()) {
            lastNull = true;
            return 0;
        }

        return value.getInt();
    }

    //------------------------------------------------------------------------
    // getLong - JDBC API
    // Get the value of a column in the current row as a Java long.
    //
    //    columnIndex        the first column is 1, the second is 2, ...
    //
    // Returns the column value; if the value is SQL NULL the result is 0
    //------------------------------------------------------------------------

    public long getLong(
        int columnIndex)
        throws SQLException
    {
        // We could coerce the data, but for now an exception is thrown

        throw DataTypeNotSupported();
    }

    //------------------------------------------------------------------------
    // getFloat - JDBC API
    // Get the value of a column in the current row as a Java float.
    //
    //    columnIndex        the first column is 1, the second is 2, ...
    //
    // Returns the column value; if the value is SQL NULL the result is 0
    //------------------------------------------------------------------------

    public float getFloat(
        int columnIndex)
        throws SQLException
    {
        // We could coerce the data, but for now an exception is thrown

        throw DataTypeNotSupported();
    }

    //------------------------------------------------------------------------
    // getDouble - JDBC API
    // Get the value of a column in the current row as a Java double.
    //
    //    columnIndex        the first column is 1, the second is 2, ...
    //
    // Returns the column value; if the value is SQL NULL the result is 0
    //------------------------------------------------------------------------

    public double getDouble(
        int columnIndex)
        throws SQLException
    {
        // We could coerce the data, but for now an exception is thrown

        throw DataTypeNotSupported();
    }

    //------------------------------------------------------------------------
    // getBigDecimal - JDBC API
    // Get the value of a column in the current row as a java.math.BigDecimal
    // object.
    //
    //    columnIndex        the first column is 1, the second is 2, ...
    //    scale            the number of digits to the right of the decimal
    //
    // Returns the column value; if the value is SQL NULL the result is null
    //------------------------------------------------------------------------

    public java.math.BigDecimal getBigDecimal(
        int columnIndex,
        int scale)
        throws SQLException
    {
        String s = getString(columnIndex);
        java.math.BigDecimal d = null;

        if (s != null) {
            java.math.BigInteger i = new java.math.BigInteger(s);
            d = new java.math.BigDecimal (i, scale);
        }
        return d;
    }

    //------------------------------------------------------------------------
    // getBytes - JDBC API
    // Get the value of a column in the current row as a Java byte array.
    // The bytes represent the raw values returned by the driver.
    //
    //    columnIndex        the first column is 1, the second is 2, ...
    //
    // Returns the column value; if the value is SQL NULL the result is null
    //------------------------------------------------------------------------

    public byte[] getBytes(
        int columnIndex)
        throws SQLException
    {
        // Verify the column

        verify(columnIndex);

        byte b[] = null;

        if (inMemoryRows != null) {
            b = (getColumn(rowNum, columnIndex)).getBytes();
        }
        else {
            CommonValue value = getValue(columnIndex);

            if (value != null) {
                b = value.getBytes();
            }
        }

        if (b == null) {
            lastNull = true;
        }

        return b;
    }

    //------------------------------------------------------------------------
    // getDate - JDBC API
    // Get the value of a column in the current row as a java.sql.Date object.
    //
    //    columnIndex        the first column is 1, the second is 2, ...
    //
    // Returns the column value; if the value is SQL NULL the result is null
    //------------------------------------------------------------------------

    public java.sql.Date getDate(
        int columnIndex)
        throws SQLException
    {
        // We could coerce the data, but for now an exception is thrown

        throw DataTypeNotSupported();
    }

    //------------------------------------------------------------------------
    // getTime - JDBC API
    // Get the value of a column in the current row as a java.sql.Time object.
    //
    //    columnIndex        the first column is 1, the second is 2, ...
    //
    // Returns the column value; if the value is SQL NULL the result is null
    //------------------------------------------------------------------------

    public java.sql.Time getTime(
        int columnIndex)
        throws SQLException
    {
        // We could coerce the data, but for now an exception is thrown

        throw DataTypeNotSupported();
    }

    //------------------------------------------------------------------------
    // getTimestamp - JDBC API
    // Get the value of a column in the current row as a java.sql.Timestamp
    // object.
    //
    //    columnIndex        the first column is 1, the second is 2, ...
    //
    // Returns the column value; if the value is SQL NULL the result is null
    //------------------------------------------------------------------------

    public java.sql.Timestamp getTimestamp(
        int columnIndex)
        throws SQLException
    {
        // We could coerce the data, but for now an exception is thrown

        throw DataTypeNotSupported();
    }

    //------------------------------------------------------------------------
    // A column value can be retrieved as a stream of ASCII characters
    // and then read in chunks from the stream.  This method is particularly
    // suitable for retrieving large LONGVARCHAR values.  The JDBC driver will
    // do any necessary conversion from the database format into ASCII.
    //
    // Note:  All the data in the returned stream must
    // be read prior to getting the value of any other column. The
    // next call to a get method implicitly closes the stream.
    //
    //    columnIndex        the first column is 1, the second is 2, ...
    //
    // Returns a Java input stream that delivers the database column value
    // as a stream of one byte ASCII characters.  If the value is SQL NULL
    // then the result is null.
    //------------------------------------------------------------------------

    public java.io.InputStream getAsciiStream(
        int columnIndex)
        throws SQLException
    {
        // Binary InputStreams are the only InputStream types supported

        throw DataTypeNotSupported();
    }

    //------------------------------------------------------------------------
    // getUnicodeStream - JDBC API
    // A column value can be retrieved as a stream of Unicode characters
    // and then read in chunks from the stream.  This method is particularly
    // suitable for retrieving large LONGVARCHAR values.  The JDBC driver will
    // do any necessary conversion from the database format into Unicode.
    //
    // Note:  All the data in the returned stream must
    // be read prior to getting the value of any other column. The
    // next call to a get method implicitly closes the stream.
    //
    //    columnIndex        the first column is 1, the second is 2, ...
    //
    // Returns a Java input stream that delivers the database column value
    // as a stream of two byte Unicode characters.  If the value is SQL NULL
    // then the result is null.
    //------------------------------------------------------------------------

    public java.io.InputStream getUnicodeStream(
        int columnIndex)
        throws SQLException
    {
        // Binary InputStreams are the only InputStream types supported

        throw DataTypeNotSupported();
    }

    //------------------------------------------------------------------------
    // getBinaryStream - JDBC API
    // A column value can be retrieved as a stream of uninterpreted bytes
    // and then read in chunks from the stream.  This method is particularly
    // suitable for retrieving large LONGVARBINARY values.
    //
    // Note:  All the data in the returned stream must
    // be read prior to getting the value of any other column. The
    // next call to a get method implicitly closes the stream.
    //
    //    columnIndex        the first column is 1, the second is 2, ...
    //
    // Returns a Java input stream that delivers the database column value
    // as a stream of uninterpreted bytes.  If the value is SQL NULL
    // then the result is null.
    //------------------------------------------------------------------------

    public java.io.InputStream getBinaryStream(
        int columnIndex)
        throws SQLException
    {
        // Verify the column

        verify(columnIndex);

        CommonValue value = null;

        if (inMemoryRows != null) {
            value = getColumn(rowNum, columnIndex);
        }
        else {
            value = getValue(columnIndex);
        }

        int length = -1;

        // Get the length, if possible

        if (value != null) {
            byte b[] = value.getBytes();
            if (b != null) {
                length = b.length;
            }
        }

        SimpleTextInputStream inputStream = new SimpleTextInputStream(
                    value, SimpleTextInputStream.STREAM_TYPE_BINARY,
                    length);

        return inputStream;
    }


    //======================================================================
    // Methods for accessing results by column name
    //======================================================================

    //------------------------------------------------------------------------
    // getString - JDBC API
    // Get the value of a column in the current row as a Java String.
    //
    //    columnName        is the SQL name of the column
    //
    // Returns the column value; if the value is SQL NULL the result is null
    //------------------------------------------------------------------------

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

    //------------------------------------------------------------------------
    // getBoolean - JDBC API
    // Get the value of a column in the current row as a Java boolean.
    //
    //    columnName        is the SQL name of the column
    //
    // Returns the column value; if the value is SQL NULL the result is false
    //------------------------------------------------------------------------

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

    //------------------------------------------------------------------------
    // getByte - JDBC API
    // Get the value of a column in the current row as a Java byte.
    //
    //    columnName        is the SQL name of the column
    //
    // Returns the column value; if the value is SQL NULL the result is 0
    //------------------------------------------------------------------------

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

    //------------------------------------------------------------------------
    // getShort - JDBC API
    // Get the value of a column in the current row as a Java short.
    //
    //    columnName        is the SQL name of the column
    //
    // Returns the column value; if the value is SQL NULL the result is 0
    //------------------------------------------------------------------------

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

    //------------------------------------------------------------------------
    // getInt - JDBC API
    // Get the value of a column in the current row as a Java int.
    //
    //    columnName        is the SQL name of the column
    //
    // Returns the column value; if the value is SQL NULL the result is 0
    //------------------------------------------------------------------------

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

    //------------------------------------------------------------------------
    // getLong - JDBC API
    // Get the value of a column in the current row as a Java long.
    //
    //    columnName        is the SQL name of the column
    //
    // Returns the column value; if the value is SQL NULL the result is 0
    //------------------------------------------------------------------------

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

    //------------------------------------------------------------------------
    // getFloat - JDBC API
    // Get the value of a column in the current row as a Java float.
    //
    //    columnName        is the SQL name of the column
    //
    // Returns the column value; if the value is SQL NULL the result is 0
    //------------------------------------------------------------------------

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

    //------------------------------------------------------------------------
    // getDouble - JDBC API
    // Get the value of a column in the current row as a Java double.
    //
    //    columnName        is the SQL name of the column
    //
    // Returns the column value; if the value is SQL NULL the result is 0
    //------------------------------------------------------------------------

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

    //------------------------------------------------------------------------
    // getBigDecimal - JDBC API
    // Get the value of a column in the current row as a java.math.BigDecimal
    // object.
    //
    //    columnName        is the SQL name of the column
    //    scale            the number of digits to the right of the decimal
    //
    // Returns the column value; if the value is SQL NULL the result is null
    //------------------------------------------------------------------------

    public java.math.BigDecimal getBigDecimal(
        String columnName,
        int scale)
        throws SQLException
    {
        return getBigDecimal(findColumn(columnName), scale);
    }

    //------------------------------------------------------------------------
    // getBytes - JDBC API
    // Get the value of a column in the current row as a Java byte array.
    // The bytes represent the raw values returned by the driver.
    //
    //    columnName        is the SQL name of the column
    //
    // Returns the column value; if the value is SQL NULL the result is null
    //------------------------------------------------------------------------

    public byte[] getBytes(
        String columnName)
        throws SQLException
    {
        return getBytes(findColumn(columnName));
    }

    //------------------------------------------------------------------------
    // getDate - JDBC API
    // Get the value of a column in the current row as a java.sql.Date object.
    //
    //    columnName        is the SQL name of the column
    //
    // Returns the column value; if the value is SQL NULL the result is null
    //------------------------------------------------------------------------

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

    //------------------------------------------------------------------------
    // getTime - JDBC API
    // Get the value of a column in the current row as a java.sql.Time object.
    //
    //    columnName        is the SQL name of the column
    //
    // Returns the column value; if the value is SQL NULL the result is null
    //------------------------------------------------------------------------

    public java.sql.Time getTime(
        String columnName)
        throws SQLException
    {
        return getTime(findColumn(columnName));
    }

    //------------------------------------------------------------------------
    // getTimestamp - JDBC API
    // Get the value of a column in the current row as a java.sql.Timestamp
    // object.
    //
    //    columnName        is the SQL name of the column
    // Returns the column value; if the value is SQL NULL the result is null
    //------------------------------------------------------------------------

    public java.sql.Timestamp getTimestamp(
        String columnName)
        throws SQLException
    {
        return getTimestamp(findColumn(columnName));
    }

    //------------------------------------------------------------------------
    // getAsciiStream
    // A column value can be retrieved as a stream of ASCII characters
    // and then read in chunks from the stream.  This method is particularly
    // suitable for retrieving large LONGVARCHAR values.  The JDBC driver will
    // do any necessary conversion from the database format into ASCII.
    //
    // Note:  All the data in the returned stream must
    // be read prior to getting the value of any other column. The
    // next call to a get method implicitly closes the stream.
    //
    //    columnName        is the SQL name of the column
    //
    // Returns a Java input stream that delivers the database column value
    // as a stream of one byte ASCII characters.  If the value is SQL NULL
    // then the result is null.
    //------------------------------------------------------------------------

    public java.io.InputStream getAsciiStream(
        String columnName)
        throws SQLException
    {
        return getAsciiStream(findColumn(columnName));
    }

    //------------------------------------------------------------------------
    // getUnicodeStream - JDBC API
    // A column value can be retrieved as a stream of Unicode characters
    // and then read in chunks from the stream.  This method is particularly
    // suitable for retrieving large LONGVARCHAR values.  The JDBC driver will
    // do any necessary conversion from the database format into Unicode.
    //
    // Note:  All the data in the returned stream must
    // be read prior to getting the value of any other column. The
    // next call to a get method implicitly closes the stream.
    //
    //    columnName        is the SQL name of the column
    //
    // Returns a Java input stream that delivers the database column value
    // as a stream of two byte Unicode characters.  If the value is SQL NULL
    // then the result is null.
    //------------------------------------------------------------------------

    public java.io.InputStream getUnicodeStream(
        String columnName)
        throws SQLException
    {
        return getUnicodeStream(findColumn(columnName));
    }

    //------------------------------------------------------------------------
    // getBinaryStream - JDBC API
    // A column value can be retrieved as a stream of uninterpreted bytes
    // and then read in chunks from the stream.  This method is particularly
    // suitable for retrieving large LONGVARBINARY values.
    //
    // Note:  All the data in the returned stream must
    // be read prior to getting the value of any other column. The
    // next call to a get method implicitly closes the stream.
    //
    //    columnName        is the SQL name of the column
    //
    // Returns a Java input stream that delivers the database column value
    // as a stream of uninterpreted bytes.  If the value is SQL NULL
    // then the result is null.
    //------------------------------------------------------------------------

    public java.io.InputStream getBinaryStream(
        String columnName)
        throws SQLException
    {
        return getBinaryStream(findColumn(columnName));
    }


    //=====================================================================
    // Advanced features:
    //=====================================================================

    //------------------------------------------------------------------------
    // getWarnings - JDBC API
    // The first warning reported by calls on this ResultSet is
    // returned. Subsequent ResultSet warnings will be chained to this
    // SQLWarning.
    //
    // The warning chain is automatically cleared each time a new
    // row is read.
    //
    // Note:  This warning chain only covers warnings caused
    // by ResultSet methods.  Any warning caused by statement methods
    // (such as reading OUT parameters) will be chained on the
    // Statement object.
    //
    // Returns the first SQLWarning or null
    //------------------------------------------------------------------------

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

    //------------------------------------------------------------------------
    // clearWarnings - JDBC API
    // After this call getWarnings returns null until a new warning is
    // reported for this ResultSet.
    //------------------------------------------------------------------------

    public void clearWarnings()
        throws SQLException
    {
        setWarning(null);
    }

    //------------------------------------------------------------------------
    // setWarning
    // Sets the given SQLWarning in the warning chain.  If null, the
    // chain is reset
    //------------------------------------------------------------------------

    protected void setWarning(
        SQLWarning warning)
    {
        if (warning == null) {
            lastWarning = null;
        }
        else {
            SQLWarning chain = lastWarning;

            // Find the end of the chain

            while (chain.getNextWarning() != null) {
                chain = chain.getNextWarning();
            }

            // We're at the end of the chain.  Add the new warning

            chain.setNextWarning(warning);
        }
    }

    //------------------------------------------------------------------------
    // getCursorName - JDBC API
    // Get the name of the SQL cursor used by this ResultSet.
    //
    // In SQL, a result table is retrieved through a cursor that is
    // named. The current row of a result can be updated or deleted
    // using a positioned update/delete statement that references the
    // cursor name.
    //
    // JDBC supports this SQL feature by providing the name of the
    // SQL cursor used by a ResultSet. The current row of a ResultSet
    // is also the current row of this SQL cursor.
    //
    // Note:  If positioned update is not supported a
    // SQLException is thrown
    //
    // Returns the ResultSet's SQL cursor name
    //------------------------------------------------------------------------

    public String getCursorName()
        throws SQLException
    {
        // The SimpleText driver does not support positioned updates

        throw DriverNotCapable();
    }

    //------------------------------------------------------------------------
    // getMetaData - JDBC API
    // The number, types and properties of a ResultSet's columns
    // are provided by the getMetaData method.
    //
    // Returns the description of a ResultSet's columns
    //------------------------------------------------------------------------

    public ResultSetMetaData getMetaData()
        throws SQLException
    {
        SimpleTextResultSetMetaData md = new SimpleTextResultSetMetaData();

        md.initialize(inMemoryColumns, ownerConnection.isReadOnly());

        return md;
    }

    //------------------------------------------------------------------------
    // getObject - JDBC API
    // Get the value of a column as a Java object.
    //
    // This method will return the value of the given column as a Java
    // object.  The type of the Java object will be default Java Object type
    // corresponding to the column's SQL type, following the mapping
    // specified in the JDBC spec.
    //
    // This method may also be used to read datatabase specific abstract
    // data types.
    //
    //    columnIndex the first column is 1, the second is 2, ...
    //
    // Returns A java.lang.Object holding the column value.
    //------------------------------------------------------------------------

    public Object getObject(
        int columnIndex)
        throws SQLException
    {

        // Verify the column

        verify(columnIndex);

        // Get the data type of the column

        int type = (getColumn(columnIndex)).type;

        // The CommonValue for the column

        CommonValue value;

        if (inMemoryRows != null) {
            value = getColumn(rowNum, columnIndex);
        }
        else {
            value = getValue(columnIndex);
        }

        // Check for a null value

        if (value == null) {
            lastNull = true;
            return null;
        }

        if (value.isNull()) {
            lastNull = true;
            return null;
        }

        Object o = null;

        // Return the appropriate object for the given type

        switch(type) {
        case Types.VARCHAR:
            o = value.getString();
            break;
        case Types.INTEGER:
            o = new Integer(value.getInt());
            break;
        case Types.VARBINARY:
            o = value.getBytes();
            break;
        default:
            throw DataTypeNotSupported();
        }
        return o;
    }

    //------------------------------------------------------------------------
    // getObject - JDBC API
    // Get the value of a parameter as a Java object.
    //
    // This method will return the value of the given column as a Java
    // object.  The type of the Java object will be default Java Object type
    // corresponding to the column's SQL type, following the mapping
    // specified in the JDBC spec.
    //
    // This method may also be used to read datatabase specific abstract
    // data types.
    //
    //    columnName        is the SQL name of the column
    //
    // Returns A java.lang.Object holding the column value.
    //------------------------------------------------------------------------

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


    //------------------------------------------------------------------------
    // findColumn - JDBC API
    // Map a Resultset column name to a ResultSet column index.
    //
    //    columnName    the name of the column
    //
    // Returns the column index
    //
    // Note:  The code implemented here comes from appendix C of the
    // JDBC API.
    //------------------------------------------------------------------------

    public int findColumn(
        String columnName)
        throws SQLException
    {
        // Make a mapping cache if we don't already have one.

        if (md == null) {
            md = getMetaData();
            s2c = new Hashtable();
        }

        // Look for the mapping in our cache

        Integer x = (Integer) s2c.get(columnName);

        if (x != null) {
            return (x.intValue());
        }

        // OK, we'll have to use metadata

        for (int i = 1; i <= md.getColumnCount(); i++) {
            if (md.getColumnName(i).equalsIgnoreCase(columnName)) {

                // Success!  Add an entry to the cache

                s2c.put(columnName, new Integer(i));
                return (i);
            }
        }

        throw new SQLException("Column name not found: " + columnName,
                            "S0022");
    }

    //------------------------------------------------------------------------
    // verify
    // Verifies the column number given is valid, and resets the warnings
    // and null indicator.  Returns the absolute column number.
    //------------------------------------------------------------------------

    protected int verify(
        int column)
        throws SQLException
    {
        clearWarnings();
        lastNull = false;

        SimpleTextColumn col = (SimpleTextColumn) inMemoryColumns.get(
                                    new Integer(column));

        if (col == null) {
            throw new SQLException("Invalid column number: " + column);
        }
            return col.colNo;
    }

    //------------------------------------------------------------------------
    // getColumn
    // Given a row and column number, return the CommonValue object from
    // the inMemoryRows
    //------------------------------------------------------------------------

    protected CommonValue getColumn(
        int rowNum,
        int column)
        throws SQLException
    {

        // First, get the row

        Hashtable row = (Hashtable) inMemoryRows.get(new Integer(rowNum));

        if (row == null) {
            throw new SQLException("Invalid row number: " + rowNum);
        }

        // Get the value

        CommonValue value = (CommonValue) row.get(new Integer(column));

        if (value == null) {

            // Column wasn't found.  Return a null value

            value = new CommonValue();
        }

        return value;
    }

    private Hashtable s2c;                    // Maps strings to column indexes
    private ResultSetMetaData md;            // Our metadata object

    //------------------------------------------------------------------------
    // openSDF
    // Opens the simple data file
    //------------------------------------------------------------------------

    protected void openSDF(
        String catalog,
        String table)
        throws SQLException
    {
        String fullName = catalog + "/" + table +
                    SimpleTextDefine.DATA_FILE_EXT;

        String sbfName = catalog + "/" + table +
                    SimpleTextDefine.BINARY_FILE_EXT;

        // Make sure the file exists

        SDF = new File(fullName);
        SBF = new File(sbfName);

        if (!SDF.exists()) {
            throw new SQLException("Text file does not exist: " + fullName);
        }

        try {
            // Create our random access object (read only)

            rafSDF = new RandomAccessFile(SDF, "r");
        }
        catch (Exception ex) {
            throw new SQLException("Unable to access file: " +ex.getMessage());
        }

        // Read past the first line (the column definitions).  Before
        // we got to this point, the Statement object verified that
        // it is a valid file

        readLine(rafSDF);
    }

    //------------------------------------------------------------------------
    // readLine
    // Given a random access file object, read the next line.  Returns null
    // if eof
    //------------------------------------------------------------------------

    protected String readLine(
        RandomAccessFile f)
        throws SQLException
    {
        String s = null;

        try {
            if (f.getFilePointer() >= f.length()) {
                return null;
            }

            s = f.readLine();
        }
        catch (Exception ex) {
            throw new SQLException("Error reading file: " + ex.getMessage());
        }
        return s;
    }

    //------------------------------------------------------------------------
    // readSBF
    // Given an offset, read the binary file and return a byte array
    //------------------------------------------------------------------------

    protected byte[] readSBF(
        int offset)
        throws SQLException
    {

        // Invalid offset, return null

        if (offset < 0) {
            return null;
        }

        byte b[] = null;

        // First time, check to make sure it exists

        if (rafSBF == null) {
            if (!SBF.exists()) {
                throw new SQLException("Binary file does not exist");
            }
        }

        try {

            // First time, create random access file object

            if (rafSBF == null) {
                rafSBF = new RandomAccessFile(SBF, "r");
            }

            // Position to the given offset

            rafSBF.seek(offset);

            // Make sure there is enough file to read an int

            if ((rafSBF.getFilePointer() + 4) > rafSBF.length()) {
                throw new SQLException("Attempt to read beyond end-of-file");
            }

            // Read the length of the data

            int len = rafSBF.readInt();

            // Make sure there's enough data to read

            if ((rafSBF.getFilePointer() + len) > rafSBF.length()) {
                throw new SQLException("Attempt to read beyond end-of-file");
            }

            b = new byte[len];
            rafSBF.read(b);

        }
        catch (Exception ex) {
            throw new SQLException("Unable to access SBF: " + ex.getMessage());
        }

        return b;
    }

    //------------------------------------------------------------------------
    // getValue
    // Returns a CommonValue object for the given column
    //------------------------------------------------------------------------

    protected CommonValue getValue(
        int column)
        throws SQLException
    {
        CommonValue value;

        // Get the column definition (we already know it's there)

        SimpleTextColumn col = (SimpleTextColumn) inMemoryColumns.get(
                                    new Integer(column));

//        value = (CommonValue) columnValues.get(new Integer(column));
        value = (CommonValue) columnValues.get(new Integer(col.colNo));

        if (value == null) {
            return null;
        }

        switch(col.type) {

        // For binary types, read the binary file

        case Types.VARBINARY:
            {
                byte b[] = readSBF(value.getInt());
                value = new CommonValue(b);
            }
            break;
        }

        return value;

    }

    //------------------------------------------------------------------------
    // filter
    // Given a Hashtable of column values and a select filter, determine if
    // the data is valid.  Returns true if the row is valid.
    //------------------------------------------------------------------------

    protected boolean filterRow(
        Hashtable values,
        SimpleTextFilter filter)
        throws SQLException
    {
        if (filter == null) {
            return true;
        }

        boolean valid = false;

        // Get the column number

        int column = filter.column.colNo;

        // Get the data for the column

        CommonValue value = (CommonValue) values.get(new Integer(column));

        // If we didn't find the column, invalidate the column

        if (value == null) {
            return false;
        }

        switch(filter.column.type) {

        // Perform integer comparisions

        case Types.INTEGER:
            {
                int icol = value.getInt();
                int ifilter = filter.value.getInt();
                switch (filter.operator) {
                case SimpleTextFilter.OP_EQ:
                    valid = (icol == ifilter);
                    break;
                case SimpleTextFilter.OP_GT:
                    valid = (icol > ifilter);
                    break;
                case SimpleTextFilter.OP_LT:
                    valid = (icol < ifilter);
                    break;
                case SimpleTextFilter.OP_NE:
                    valid = (icol != ifilter);
                    break;
                }
            }
            break;

        // By default, compare as a string

        default:
            {
                String scol = value.getString();
                String sfilter = filter.value.getString();
                switch (filter.operator) {
                case SimpleTextFilter.OP_EQ:
                    valid = (scol.equals(sfilter));
                    break;
                case SimpleTextFilter.OP_GT:
                    valid = (scol.compareTo(sfilter) > 0);
                    break;
                case SimpleTextFilter.OP_LT:
                    valid = (scol.compareTo(sfilter) < 0);
                    break;
                case SimpleTextFilter.OP_NE:
                    valid = (!scol.equals(sfilter));
                    break;
                }
            }

            break;
        }

        return valid;
    }

    //------------------------------------------------------------------------
    // getColumn
    // Returns the SimpleTextColumn object for the given column number.
    // If not found, an exception is thrown
    //------------------------------------------------------------------------

    protected SimpleTextColumn getColumn(
        int col)
        throws SQLException
    {
        SimpleTextColumn column = (SimpleTextColumn)
                        inMemoryColumns.get(new Integer(col));

        if (column == null) {
            throw new SQLException("Invalid column number: " + col);
        }

        return column;
    }



    // SQLWarning chain

    protected SQLWarning lastWarning;

    // Owning statement object

    protected SimpleTextIStatement ownerStatement;

    // Owning connection object

    protected SimpleTextIConnection ownerConnection;

    // Hashtable containing a SimpleTextColumn object for each column
    // in the result set.  Used for catalog functions as well as normal
    // tables

    protected Hashtable inMemoryColumns;

    // Hashtable containing another Hashtable for each row.  Used for
    // catalog functions

    protected Hashtable inMemoryRows;

    // Current row number (for in-memory result sets)

    protected int rowNum;

    // true if the last row accessed was null

    protected boolean lastNull;

    // File objects for the simple data file and simple binary file

    File SDF;
    File SBF;
    RandomAccessFile rafSDF;
    RandomAccessFile rafSBF;

    // Current text line

    String currentLine;

    // Current data values (CommonValue objects)

    Hashtable columnValues;

    // SimpleTextFilter object for select WHERE clause

    SimpleTextFilter selectFilter;
}

//----------------------------------------------------------------------------
// SimpleTextFilter
// Class to represent a filter for a SELECT statement (i.e. the WHERE clause).
// This class is package-private
//----------------------------------------------------------------------------

class SimpleTextFilter
{
    SimpleTextColumn    column;
    int                    operator;

        public final static int OP_EQ    = 1;
        public final static int OP_GT    = 2;
        public final static int OP_LT    = 3;
        public final static int    OP_NE    = 4;

    CommonValue            value;
}