Quadcap Embeddable Database

com/quadcap/sql/StaticCursor.java

Go to the documentation of this file.

package com.quadcap.sql;

/* Copyright 1999 - 2003 Quadcap Software.  All rights reserved.
 *
 * This software is distributed under the Quadcap Free Software License.
 * This software may be used or modified for any purpose, personal or
 * commercial.  Open Source redistributions are permitted.  Commercial
 * redistribution of larger works derived from, or works which bundle
 * this software requires a "Commercial Redistribution License"; see
 * http://www.quadcap.com/purchase.
 *
 * Redistributions qualify as "Open Source" under  one of the following terms:
 *   
 *    Redistributions are made at no charge beyond the reasonable cost of
 *    materials and delivery.
 *
 *    Redistributions are accompanied by a copy of the Source Code or by an
 *    irrevocable offer to provide a copy of the Source Code for up to three
 *    years at the cost of materials and delivery.  Such redistributions
 *    must allow further use, modification, and redistribution of the Source
 *    Code under substantially the same terms as this license.
 *
 * Redistributions of source code must retain the copyright notices as they
 * appear in each source code file, these license terms, and the
 * disclaimer/limitation of liability set forth as paragraph 6 below.
 *
 * Redistributions in binary form must reproduce this Copyright Notice,
 * these license terms, and the disclaimer/limitation of liability set
 * forth as paragraph 6 below, in the documentation and/or other materials
 * provided with the distribution.
 *
 * The Software is provided on an "AS IS" basis.  No warranty is
 * provided that the Software is free of defects, or fit for a
 * particular purpose.  
 *
 * Limitation of Liability. Quadcap Software shall not be liable
 * for any damages suffered by the Licensee or any third party resulting
 * from use of the Software.
 */

import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;

import java.util.Collections;
import java.util.Comparator;
import java.util.Vector;

import java.sql.SQLException;

import com.quadcap.sql.types.Op;
import com.quadcap.sql.types.Value;
import com.quadcap.sql.types.ValueException;

import com.quadcap.util.Debug;

/**
 * Cursor implementation of <b>VALUES</b> clause.  Contains either a row
 * or a Vector of rows.
 *
 * @author Stan Bailes
 */
public class StaticCursor extends CursorImpl implements Externalizable {
    Tuple                               tuple           = null;
    Vector                              v;
    Row                                 currentRow      = null;
    int                                 pos             = 0;

    /**
     * Constructor for a static cursor from a tuple and single row
     */
    public StaticCursor(Session session, Tuple tuple, Row row) {
        super(session, "");
        this.tuple = tuple;
        this.v = new Vector();
        v.addElement(row);
    }

    /**
     * Constructor for a static cursor from a vector of rows.
     */
    public StaticCursor(Session session, Vector v) {
        super(session, "");
        this.v = v;
    }

    /**
     * Add a row to the cursor's row set.
     */
    public void addRow(Row row) {
        v.addElement(row);
    }

    /**
     * Return the current row
     */
    public Row getRow() {
        return currentRow;
    }

    /**
     * Static cursors aren't updateable.
     */
    public void updateRow(Row row) throws SQLException {
        throw new SQLException("Not implemented for static cursor", "0A000");
    }

    /**
     * Static cursors aren't updateable.
     */
    public void deleteRow() throws SQLException {
        throw new SQLException("Not implemented for static cursor", "0A000");
    }

    /**
     * Return the specified column.
     *
     * Static cursors may or may not have tuple information.  If they
     * do, use the tuple information directly, otherwise default to the
     * superclass (TupleImpl) implementation of getColumn.
     */
    public Column getColumn(int col) throws SQLException {
        if (tuple == null) {
            return super.getColumn(col);
        }
        return tuple.getColumn(col);
    }

    /**
     * Return the specified column.
     *
     * Static cursors may or may not have tuple information.  If they
     * do, use the tuple information directly, otherwise default to the
     * superclass (TupleImpl) implementation of getColumn.
     */
    public Column getColumn(String columnName) throws SQLException {
        if (tuple == null) {
            return super.getColumn(columnName);
        }
        return tuple.getColumn(columnName);
    }

    /**
     * Get the value for the specified column
     */
    public Value get(String columnName) throws SQLException {
        Column col = getColumn(columnName);
        if (col != null) {
            return currentRow.item(col.getColumn());
        }
        return null;
    }

    /**
     * Put a new value into the current row for the specified column
     *   (Who calls this?  We're not supposed to be writable!!!)
     */
    public void put(String columnName, Value v) throws SQLException {
        Column col = getColumn(columnName);
        if (col != null) {
            currentRow.set(col.getColumn(), v);
        }
    }

    /**
     * Return the column count.
     */
    public int getColumnCount() throws SQLException {
        if (tuple != null) return tuple.getColumnCount();
        int ret = super.getColumnCount();
        if (ret > 0) return ret;
        if (v.size() > 0) {
            Row row = (Row)v.elementAt(0);
            return row.size();
        }
        throw new SQLException("no columns", "Q0017");
    }

    /**
     * Static cursors don't allow column update
     */
    public boolean isWritable(int column) { return false; }

    /**
     * Return the number of rows in this cursor.
     */
    public long size() throws SQLException { return v.size(); }
    
    /**
     * Position the cursor to the specified absolute row.  The first row
     * is row '1', and the last row is '-1', as in JDBC.
     */
    public boolean absolute(int row) throws SQLException {
        currentRow = null;
        if (row == 0) {
            throw new SQLException("Attempt to position cursor on row zero",
                                   "42000");
        }
        if (row < 0) {
            row += v.size();
        }
        if (row <= 0 || row > v.size()) return false;
        currentRow = (Row)v.elementAt(row-1);
        return true;
    }

    /**
     * Position the cursor before the first row.
     */
    public void beforeFirst() throws SQLException {
        pos = 0;
    }

    /**
     * Position the cursor after the last row.
     */
    public void afterLast() throws SQLException {
        pos = v.size();
    }

    /**
     * Move the cursor to the next row and return true if the cursor is
     * positioned on a valid row.
     */
    public boolean next() {
        currentRow = null;
        if (pos < v.size()) {
            currentRow = (Row)v.elementAt(pos++);
        }
        return currentRow != null;
    }

    /**
     * Move the cursor to the previous row and return true if the cursor is
     * positioned on a valid row.
     */
    public boolean prev() {
        currentRow = null;
        if (pos > 0 && pos <= v.size()) {
            currentRow = (Row)v.elementAt(--pos);
        }
        return currentRow != null;
    }

    /**
     * Read me from a stream
     */
    public void readExternal(ObjectInput in)
        throws IOException, ClassNotFoundException
    {
        this.pos = in.readInt();
        this.v = (Vector)in.readObject();
    }

    /**
     * Write me to a stream
     */
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeInt(pos);
        out.writeObject(v);
    }

    /**
     * Close.
     */
    public void close() {
        tuple = null;
        currentRow = null;
        v = null;
    }

    public int[] getSortColumns() {
        return new int[0];
    }

    public Comparator getComparator() {
        return new Comparator() {
            public int compare(Object o1, Object o2) {
                try {
                    Row r1 = (Row)o1;
                    Row r2 = (Row)o2;
                    int[] keys = getSortColumns();
                    for (int i = 0; i < keys.length; i++) {
                        int col = keys[i];
                        Value v1 = r1.item(col);
                        Value v2 = r2.item(col);
                        if (Value.boolOp(Op.LT, v1, v2)) return -1;
                        if (Value.boolOp(Op.GT, v1, v2)) return 1;
                    }
                } catch (ValueException e) {
                    Debug.print(e);
                    throw new DbRuntimeException(e);
                } catch (SQLException e) {
                    Debug.print(e);
                    throw new DbRuntimeException(e);
                } catch (Throwable e) {
                    Debug.print(e);
                    throw new DbRuntimeException(e);
                }
                return 0;
            }
        };
    }

    public void sort() throws ValueException, SQLException {
        try {
            Collections.sort(v, getComparator());
        } catch (DbRuntimeException e) {
            Throwable ex = e.getException();
            if (ex instanceof ValueException) {
                throw (ValueException)ex;
            } else if (ex instanceof SQLException) {
                throw (SQLException)ex;
            } else {
                throw e;
            }
        }
    }

    public void updateRow(int pos, Row row) {
        v.setElementAt(row, pos);
    }

    public void reset() {
        pos = 0;
    }
}