Quadcap Embeddable Database

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

import java.util.Vector;

import java.sql.ResultSet;
import java.sql.SQLException;

import com.quadcap.sql.file.ByteUtil;

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

import com.quadcap.sql.file.BlockFile;

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

/**
 * Base class for all index constraints. 
 *
 * @author Stan Bailes
 */
abstract public class IndexConstraint extends Constraint
                                      implements Externalizable {
    Btree                       index                   = null; 
    long                        indexRoot               = -1;
    protected boolean           useComparator           = true;

    /**
     * Default constructor (required for Externalizable)
     */
    public IndexConstraint() {}

    /**
     * Explicit constructor for named index
     */
    public IndexConstraint(String name) {
        super(name);
    }

    public IndexConstraint(String name, Vector names) {
        super(name, names);
    }

    //------------------------------------------------------------------
    // Abstract interface: implementation required
    /**
     * Make a serialized key appropriate to the constraint type, based on
     * the row and row id information
     */
    abstract public byte[] makeKey(Session session, Row row, long rowId)
        throws SQLException
    ;

    /**
     * Derived classes must implement this function, which returns the
     * constraint type as a human readable string.
     */
    abstract public String constraintType();

    /**
     * Constraint.add(): We need to build an index!
     */
    public void add(Session session) throws SQLException, IOException {
        index = null;
        indexRoot = -1;
        resetColumns();
        getIndex(session.getDatabase());

        getColumns();
        IndexCursor c = table.getCursor(session, this);
        if (c != null) {
            try {
                while (c.next()) {
                    Row row = c.getRow();
                    long rowId = c.getRowId();
                    byte[] key = makeKey(session, row, rowId);
                    if (index.get(key) != null) {
                        throw new SQLException(constraintType() + 
                                               " constraint violated");
                    }
                    if (session.getConnection().inRecovery()) {
                        rowId = session.getLog().getRowMap(rowId);
                    }
                    index.set(key, key.length, session.getBuf8(rowId), 0, 8);
                }
            } finally {
                c.close();
            }
        }
        
    }

    /**
     * Constraint.delete(): We destroy our index
     */
    public void delete(Session session) throws IOException {
        if (indexRoot > 0) {
            Database db = session.getDatabase();            
            getIndex(db);
            if (index != null) {
                index.free();
            }
        }
    }

    /**
     * Externalizable.readExternal(): Read me from a stream
     */
    public void readExternal(ObjectInput in)
        throws IOException, ClassNotFoundException
    {
        super.readExternal(in);
        indexRoot = in.readLong();
        useComparator = in.read() == 1;
    }

    /**
     * Externalizable.writeExternal(): Write me to a stream
     */
    public void writeExternal(ObjectOutput out) throws IOException {
        super.writeExternal(out);
        out.writeLong(indexRoot);
        out.write(useComparator ? 1 : 0);
    }

    //---------------------------------
    // Constraint.checkNNN() functions
    
    /**
     * Constraint.checkInsert(): We could check for dups
     */
    public void checkInsert(Session session, Row row)
        throws SQLException, IOException
    {
    }

    public void checkUpdate(Session session, byte[] oldKey, Row row,
                            Row oldRow, long rowId, Constraint activeIndex)
        throws SQLException, IOException
    {
    }
    
    public void checkDelete(Session session, Row row, long rowId)
        throws SQLException, IOException
    {
    }

    //---------------------------------
    // Constraint.applyXXX() functions

    /**
     * Constraint.applyInsert(): Add an index entry
     */
    public void applyInsert(Session session, Row row, long rowId,
                            Constraint activeIndex)
        throws SQLException, IOException
    {
        
        Database db = session.getDatabase();
        byte[] key = makeKey(session, row, rowId);
        AddIndexEntry add = new AddIndexEntry(session, this, key, rowId);
        if (activeIndex == this) {
            session.addPendingAction(add);
        } else {
            session.doStep(add);
        }
    }

    // careful, 'oldKey' only applies to the 'activeIndex', which may not
    // be this constraint. 
    public void applyUpdate(Session session, byte[] oldKey, Row row,
                            Row oldRow, long rowId, Constraint activeIndex)
        throws SQLException, IOException
    {
        byte[] key = makeKey(session, row, rowId);
        if (activeIndex != this) {
            oldKey = makeKey(session, oldRow, rowId);
        }
        if (Util.compareBytes(key, oldKey) != 0) {
            UpdateIndex ui =
                (UpdateIndex)session.getContext(this, isDeferred());
            if (ui == null) {
                ui = new UpdateIndex(session, this);
                session.putContext(this, isDeferred(), ui);
            }
            ui.addEntry(key, oldKey, rowId);
        } else {
        }
    }

    public void applyDelete(Session session, Row row, long rowId,
                            Constraint activeIndex)
        throws SQLException, IOException
    {
        Database db = session.getDatabase();
        byte[] key = makeKey(session, row, rowId);
        
        if (index == null) getIndex(db);
        DeleteIndexEntry del = new DeleteIndexEntry(session, this, key);
        if (activeIndex == this) {
            session.addPendingAction(del);
        } else {
            session.doStep(del);
        }
    }

    /**
     * Does this constraint have enough information to uniquely identify
     * each row?
     */
    public boolean isUnique() { return true; }

    /**
     * Return the number of columns in the index implementing this constraint
     */
    public int getIndexColumnCount() {
        return getColumnCount();
    }

    /**
     * Lazy getter for underlying Index object (a Btree, in this case)
     */
    public Btree getIndex(Database db) throws IOException {
        if (index == null) {
            BlockFile file = db.getFile();
            boolean create = false;
            if (indexRoot == -1) {
                indexRoot = file.newPage();
                db.updateRelation(table);
                create = true;
            }
            if (useComparator) {
                Comparator compare = new Key(getIndexColumnCount());
                index = new Btree(file, compare, indexRoot, create);
            } else {
                index = new Btree(file, indexRoot, create);
            }
        }
        return index;
    }

   /**
    * Return a string representation of the constraint
    */
    public String toString() {
        StringBuffer sb = new StringBuffer();
        sb.append(getName());
        if (table != null) {
            sb.append("(");
            try {
                Vector v = getColumnNames();
                for (int i = 0; i < v.size(); i++) {
                    if (i > 0) sb.append(',');
                    sb.append(v.elementAt(i).toString());
                }
                sb.append(")");
            } catch (SQLException e) {
                sb.append("Exception: " + e.toString());
            }
        }
        return sb.toString();
    }
}