Quadcap Embeddable Database

com/quadcap/sql/IndexCursor.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.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;

import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Vector;

import java.sql.SQLException;

import com.quadcap.sql.io.ObjectOutputStream;

import com.quadcap.sql.file.ByteUtil;

import com.quadcap.sql.index.Btree;
import com.quadcap.sql.index.Comparator;

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

import com.quadcap.util.Debug;
import com.quadcap.util.Util;

/**
 * Cursor for iterating an index.
 *
 * @author Stan Bailes
 */
public class IndexCursor extends BC_Cursor {
    Table                               table;
    IndexConstraint                     constraint;
    Btree                               index;
    Comparator                          compare;
    Vector                              indexNames      = null;
    StaticCursor                        startVals       = null;
    StaticCursor                        stopVals        = null;

    byte[]                              startVal;
    byte[]                              stopVal;

    
    /**
     * IndexCursor construtor for the specified table (with optional
     * where clause)
     */
    public IndexCursor(Table table, Session session,
                       IndexConstraint constraint, Expression where,
                       String qualifier, Cursor outerCursor)
        throws SQLException, IOException
    {
        super(session, qualifier, outerCursor);
        this.table = table;
        this.constraint = constraint;
        this.index = constraint.getIndex(session.getDatabase());
        this.compare = index.getComparator();
        
        addColumns(session, table);

        this.indexNames = constraint.getColumnNames();
        reset(where, outerCursor);
    }
    public void checkCursor() throws SQLException {
        if (bc == null) {
            throw new SQLException("Cursor closed");
        }
    }

    public long getCurrentRowId() throws SQLException {
        checkCursor();
        return ByteUtil.getLong(bc.getValBuf(), 0);
    }

    public void fetchCurrentRow() throws SQLException, IOException {
        session.getDatabase().getRow(rowId, row, false);
        rowValid = true;
    }

    public IndexConstraint getConstraint() {
        return constraint;
    }

    public void reset(Expression where, Cursor outer)
        throws SQLException
    {
        try {
            this.setOuterCursor(outer);
            startVal = null;
            stopVal = null;
            if (indexNames != null && indexNames.size() > 0) {
                startVals = makeValues(session, table, ValueNull.valueNull);
                stopVals = makeValues(session, table, ValueNull.valueLastNull);
                getCursorRange(session, where, startVals, stopVals);
                startVal = constraint.makeKey(session, startVals.getRow(),
                                              Long.MIN_VALUE);
                stopVal = constraint.makeKey(session, stopVals.getRow(),
                                             Long.MAX_VALUE);
                //Debug.println("startVal = " + Util.hexBytes(startVal));
                //Debug.println("stopVal = " + Util.hexBytes(stopVal));
            }
            
            this.row = new LazyRow(table.getColumnCount());
            bc = index.getCursor(false);
            if (startVal != null) {
                bc.seek(startVal);
            } else {
                bc.beforeFirst();
            }
        } catch (IOException e) {
            throw DbException.wrapThrowable(e);
        }
    }

    /**
     * Make a row for the specified table and fill it with the specified
     * value
     */
    StaticCursor makeValues(Session session, Table table, Value v)
        throws SQLException
    {
        Row r = new Row(table.getColumnCount());
        for (int i = 1; i <= r.size(); i++) {
            r.set(i, v);
        }
        StaticCursor s = new StaticCursor(session, table, r);
        s.absolute(1);
        return s;
    }

    //#ifdef DEBUG
    static String isa(Object x) {
        return x == null ? "null" :
            x.getClass().getName() + ":" + x;
    }
    //#endif
    
    /**
     * Determine if an expression in the where clause can supply a lower
     * or upper bound on the value of the index key
     */
    void getCursorRange(Session session, Expression e,
                        StaticCursor startVals, StaticCursor stopVals) 
        throws SQLException 
    {
        if (e instanceof BinaryExpression) {
            BinaryExpression b = (BinaryExpression)e;
            switch (b.op) {
            case Op.EQ:
                //Debug.println("b.e = " + b.e);
                //Debug.println("b.f = " + b.f);
                //Debug.println("startVals = " + startVals);
                if (b.e instanceof NameExpression) {
                    NameExpression ne = (NameExpression)b.e;
                    String name = session.getConnection().resolveColname(ne.getName(), table);
                    String tname = table.getName();
                    if (name.startsWith(tname)) name = name.substring(tname.length() + 1);
                    //Debug.println("   name = " + name + ", tablename = " + table.getName());
                    if (startVals.get(name) != null) {
                        try {                            
                            Value v = b.f.getValue(session, outer);
                            //Debug.println("      v = " + v);
                            startVals.put(name, v);
                            stopVals.put(name, v);
                            return;
                        } catch (SQLException se) {}
                    }
                }
                if (b.f instanceof NameExpression) {
                    NameExpression nf = (NameExpression)b.f;
                    String name = session.getConnection().resolveColname(nf.getName(), table);
                    if (startVals.get(name) != null) {
                        try {
                            Value v = b.e.getValue(session, outer);
                            startVals.put(name, v);
                            stopVals.put(name, v);
                        } catch (SQLException se) {}
                    }
                }
                break;
            case Op.AND:
                getCursorRange(session, b.e, startVals, stopVals);
                getCursorRange(session, b.f, startVals, stopVals);
                break;
            case Op.LT:
            case Op.LE:
                doOneBound(session, b.e, b.f, startVals, stopVals);
                break;
            case Op.GT:
            case Op.GE:
                doOneBound(session, b.f, b.e, startVals, stopVals);
                break;
            }
        } else if (e instanceof TernaryExpression) {
            TernaryExpression t = (TernaryExpression)e;
            if (t.op == Op.BETWEEN) {
                if (!t.not) {
                    doOneBound(session, t.f, t.e, startVals, stopVals);
                    doOneBound(session, t.e, t.g, startVals, stopVals);
                }
            }
        }
    }

    /**
     * Compare a single element to a bound to determine a possible
     * limit
     */
    void doOneBound(Session session, Expression a, Expression b,
                    StaticCursor startVals, StaticCursor stopVals) 
        throws SQLException 
    {
        if (a instanceof NameExpression) {
            NameExpression na = (NameExpression)a;
            String name = na.getName();
            Value s = (Value)stopVals.get(name);
            if (s != null) {
                Value v = b.getValue(session, null);    // XXX outer?
                Value cmp = Value.binop(Op.COMPARE, v, s);
                ValueInteger vi = (ValueInteger)cmp;
                int ret = vi.intValue();
                if (ret < 0) {
                    stopVals.put(name, v);
                }
            }
        } else if (b instanceof NameExpression) {
            NameExpression nb = (NameExpression)b;
            String name = nb.getName();
            Value s = (Value)startVals.get(name);
            if (s != null) {
                Value v = a.getValue(session, null);    // XXX outer?
                Value cmp = Value.binop(Op.COMPARE, v, s);
                ValueInteger vi = (ValueInteger)cmp;
                int ret = vi.intValue();
                if (ret > 0) {
                    startVals.put(name, v);
                }
            }
        }
    }

    /**
     * Cursor.next():
     */
    public boolean next() throws SQLException {
        boolean ret = super.next();
        if (ret) {
            if (stopVal != null) {
                if (compare.compare(bc.getKeyBuf(), 0, bc.getKeyLen(),
                                    stopVal, 0, stopVal.length) > 0) {
                    ret = false;
                }
            }
        }
        return ret;
    }

    /**
     * Cursor.prev()
     */
    public boolean prev() throws SQLException {
        boolean ret = super.prev();
        if (ret) {
            if (startVal != null) {
                if (compare.compare(bc.getKeyBuf(), 0, bc.getKeyLen(),
                                    startVal, 0, startVal.length) < 0) {
                    ret = false;
                }
            }
        }
        return ret;
    }

    /**
     * Update the current row with the specified new values
     */
    public void updateRow(Row row) throws SQLException {
        try {
            TableOps.updateRow(session, table,
                               bc.getKey(), rowId,
                               row, constraint);
        } catch (IOException e) {
            throw DbException.wrapThrowable(e);
        }
    } 

    /**
     * Insert the specified row into the table referenced by this cursor
     */
    public void insertRow(Row row) throws SQLException {
        try {
            TableOps.insertRow(session, table, row);
        } catch (IOException e) {
            throw DbException.wrapThrowable(e);
        }
    }

    /**
     * Delete the current cursor row
     */
    public void deleteRow() throws SQLException {
        try {
            TableOps.deleteRow(session, table,
                               rowId, getRow(), constraint);
        } catch (IOException e) {
            throw DbException.wrapThrowable(e);
        }
    }

    /**
     * Move the cursor to the beginning; before the first row
     */
    public void beforeFirst() throws SQLException {
        try {
            rowValid = false;
            rowId = 0;
            checkCursor();
            if (startVal != null) bc.seek(startVal);
            else bc.beforeFirst();
        } catch (IOException e) {
            throw DbException.wrapThrowable(e);
        }
    }
    
    /**
     * Move the cursor to the beginning; before the first row
     */
    public void afterLast() throws SQLException {
        try {
            rowValid = false;
            rowId = 0;
            checkCursor();
            if (stopVal != null) bc.seek(stopVal);
            else bc.afterLast();
        } catch (IOException e) {
            throw DbException.wrapThrowable(e);
        }
    }
    
//      /**
//        * Absolute cursor positioning
//       */
//      public boolean absolute(int row) throws SQLException {
//          return ((CursorImpl)this).absolute(row);
//      }

    /**
     * All columns in an index cursor are writable.
     */
    public boolean isWritable(int col) {
        return true;
    }

    /**
     * Return the underlying table for this cursor.  Apparently, some poor
     * cursors don't have tables! Can you imagine!
     */
    public Table getTable() { return table; }

    //#ifdef DEBUG
    public String toString() {
        try {
            StringBuffer sb =
                new StringBuffer(Table.strip(getClass().getName()));
            sb.append(": ");
            sb.append(constraint.getName());
            if (outer != null) {
                sb.append(" (outer ");
                sb.append(outer.toString()); // Table.strip(outer.getClass().getName()));
                sb.append(")");
            }
            sb.append(" {");
            for (int i = 1; i <= getColumnCount(); i++) {
                Column c = getColumn(i);
                if (i > 1) sb.append(',');
                sb.append(c.getName());
            }
            sb.append('}');
            return sb.toString();
        } catch (Exception e) {
            Debug.print(e);
            return this.getClass().getName();
        }
    }
    //#endif
}