Quadcap Embeddable Database

com/quadcap/sql/ImportedKeyConstraint.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.io.ObjectInputStream;
import com.quadcap.sql.io.ObjectOutputStream;

import com.quadcap.sql.file.BlockFile;

import com.quadcap.sql.index.Btree;

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

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

/**
 * Constraint for imported keys (i.e., this table references another
 * table)
 *
 * @author Stan Bailes
 */
public class ImportedKeyConstraint extends ForeignKeyConstraint
implements Externalizable
{
    long                                indexRoot       = -1;
    transient Btree                     index           = null;
    transient Btree                     fIndex          = null;
    transient ExportedKeyConstraint     ec              = null;

    /**
     * Default constructor required for serialization
     */
    public ImportedKeyConstraint() {}

    /**
     * Explicit constructor parser.
     */
    public ImportedKeyConstraint(String name, String fTableName) {
        super(name, fTableName);
    }

    /**
     * Explicit constructor with named columns
     */
    public ImportedKeyConstraint(String name, Vector colNames,
                                 String fTableName, Vector fColNames) {
        super(name, colNames, fTableName, fColNames);
    }

    /**
     * For <b>ALTER TABLE ADD CONSTRAINT</b>, we need to build our
     * foreign index.
     */
    public void add(Session session) throws SQLException, IOException {
        Database db = session.getDatabase();
        BlockFile file = db.getFile();
        getFCols(db);
        if (fConstraint == null) {
            throw new SQLException("No suitable foreign key", "23000");
        }
        
        indexRoot = file.newPage();
        index = new Btree(file, indexRoot, true);

        String ecName = getExportConstraintName();
        ec = new ExportedKeyConstraint(ecName, fColNames, table.getName(),
                                       colNames, this, fConstraint);
        ec.setForeignKeyCols(getColumns());
        session.doStep(new AddConstraint(session, fTable, ec, false));

        if (!table.isUnderConstruction()) {
            IndexCursor c = table.getCursor(session, null);
            if (c != null) {
                try {
                    while (c.next()) {
                        Row row = c.getRow();
                        long rowId = c.getRowId();
                        checkInsert(session, row);
                        applyInsert(session, row, rowId, null);
                    }
                } finally {
                    c.close();
                }
            }
        }
        db.updateRelation(fTable);
    }

    /**
     * On <b>ALTER TABLE DROP CONSTRAINT</b>, delete the index and free
     * the file resources it holds.
     */
    public void delete(Session session) throws SQLException, IOException {
        // Don't bother if there isn't an index....
        if (indexRoot > 0) {
            Database db = session.getDatabase();
            getIndex(db);
            if (index != null) {
                index.free();
                index = null;
            }
            indexRoot = -1;
        }
    }

    /**
     * Return a name for the auto-generated 'export' constraint.
     */
    final String getExportConstraintName() {
        StringBuffer sb = new StringBuffer("__ec_");
        sb.append(table.getName());
        sb.append('_');
        sb.append(name);
        return sb.toString();
    }

    /**
     * On insert, verify that the referenced keys exist in the foreign
     * table.
     */
    public void checkInsert(Session session, Row row)
        throws SQLException, IOException
    {
        Database db = session.getDatabase();
        int[] k = getColumns();
        int[] fk = getFCols(db);

        Row r = new Row(fTable.getColumnCount());
        boolean anyNull = false;
        boolean allNull = true;
        for (int i = 0; i < k.length; i++) {
            int col = k[i];
            int fcol = fk[i];
            Value v = row.item(col);
            boolean isNull = Value.isNull(v);
            anyNull |= isNull;
            allNull &= isNull;
            r.set(fcol, v);
        }
        UniqueConstraint con = fTable.getIndexForColumns(fk);
        byte[] key = con.makeKey(session, r, 0);
        Btree fTree = con.getIndex(db);
        if (fTree.get(key) == null && !allNull
            && (!anyNull || ((spec & (Constraint.FULL |
                                      Constraint.PARTIAL)) != 0))) {
            if (isSelfReferencing(db) && checkSelfReferencing(row)) {
                // it's ok, after all.
            } else {
                throw new SQLException(
                    "Foreign Key Constraint Violation: no parent: " +
                    this.toString(), "23000");
            }
        }
    }

    /**
     * On insert, add the new 'export' constraint value
     */
    public void applyInsert(Session session, Row row, long rowId,
                            Constraint activeIndex)
        throws SQLException, IOException
    {
        byte[] key = makeKey(session, row, rowId);
        AddIndexEntry add = new AddIndexEntry(session, this, key, rowId);
        if (activeIndex == this) {
            session.addPendingAction(add);
        } else {
            session.doStep(add);
        }
    }

    /**
     * On delete, remove the constraints holding the corresponding
     * row values.
     */
    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);
        }
    }

    /**
     * On update, if the imported key changes, we need to modify the
     * index.  Once this happens, we create a session context in which
     * to record the index changes so we can do them all together, at
     * the end. 
     */
    public void checkUpdate(Session session, byte[] oldKey, Row row,
                            Row oldRow, long rowId, Constraint activeIndex)
        throws SQLException, IOException
    {
        checkInsert(session, row);
        getComparator();
        byte[] key = makeKey(session, row, rowId);
        if (activeIndex != this) oldKey = makeKey(session, oldRow, rowId);
        if (compare.compare(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);
        }
    }

    /**
     * Check for the possibility that a row satisfies its own constraints.
     * It's a strange world we live in, get used to it.
     */
    boolean checkSelfReferencing(Row row) throws SQLException {
        boolean anyNull = false;
        boolean allNull = true;
        boolean allMatch = true;
        for (int i = 0; i < fCols.length; i++) {
            Value v = row.item(fCols[i]);
            Value r = row.item(columns[i]);
            boolean isNull = Value.isNull(v);
            anyNull |= isNull;
            allNull &= isNull;
            if (allMatch) allMatch = Value.boolOp(Op.EQ, v, r);
        }
        if (allMatch || allNull) return true;
        if (anyNull && (spec & (Constraint.FULL | Constraint.PARTIAL)) != 0)
            return true;
        return false;
    }

    /**
     * Get (create if necessary) the Btree for the foreign index.
     */
    final Btree getForeignIndex(Session session)
        throws SQLException, IOException 
    {
        if (fIndex == null) {
            fIndex = fConstraint.getIndex(session.getDatabase());
        }
        return fIndex;
    }

    /**
     * Get the export constraint if it exists already.
     */
    public ExportedKeyConstraint findExportedKeyConstraint(Database db)
        throws IOException, SQLException
    {
        if (ec == null) {
            Table t = getFTable(db);
            String ecName = getExportConstraintName();
            ec = (ExportedKeyConstraint)t.getConstraint(ecName);
        }
        return ec;
    }

    /**
     * For the purposes of creating a unique key, the rowId is included,
     * whereas for purposes of checking foreign key integrity, the rowId
     * is ignored, only the key value matters.
     */
    byte[] makeKey(Session session, Row row, long rowId)
        throws SQLException
    {
        return Key.makeKey(table, row, getColumns(), rowId, true);      // !!
    }

    /**
     * Get the index (create it if necessary).  The key for this index includes
     * the actual key fields plus the row id to ensure uniqueness for Btreee
     * operations.  Some operations require that we use a special comparator
     * which ignores the rowId part.
     */
    public Btree getIndex(Database db) throws IOException {
        if (index == null) {
            index = new Btree(db.getFile(), indexRoot, false);
        }
        return index;
    }

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

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

}