Quadcap Embeddable Database

com/quadcap/sql/ExportedKeys.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.IOException;

import java.util.Enumeration;

import java.sql.SQLException;

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

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

/**
 * A statement context which keeps track of the set of changes to the
 * keys in a foreign-key constraint during the statement execution.
 * At statement end, we check the entire set to make sure referential
 * integrity has been maintained.
 *
 * @author Stan Bailes
 */
public class ExportedKeys implements StatementContext {
    Session                             session;
    ExportedKeyConstraint               ec;
    Btree                               index;
    BCursor                             bc;
    byte[]                              buf             = new byte[1];

    /**
     * fkey -> key
     *
     * 'k' means "insert k"
     * '~k' means "delete k"
     *
     * First case, key deleted which is not referenced:
     *    lsb Encoding of 'ok, ~nk, ~of, ~nf'   -> 1
     *
     * Second case, key deleted where foreign key is also deleted:
     *    lsb Encoding of 'ok, ~nk, of, ~nf'    -> 5
     *
     * Encoding of 1, 5: 0x0022
     */
    static final int                    valid           = 0x22;
    
    public ExportedKeys(Session session, ExportedKeyConstraint ec)
        throws IOException
    {
        this.session = session;
        this.ec = ec;
        this.index = session.makeTempTree();
        this.bc = index.getCursor(false);
    }

    void doKey(byte[] key, int bit) throws IOException {
        if (bc.seek(key) && bc.getVal(buf) == 1) {
            buf[0] |= bit;
            bc.replace(buf);
        } else {
            buf[0] = (byte)bit;
            bc.insert(key, buf);
        }
    }

    public void addDeleteSelfRef(byte[] key, byte[] fkey)
        throws IOException, SQLException
    {
        try {
            doKey(key, 1);
            doKey(fkey, 4);
        } finally {
            bc.close();
        }
    }

    public void addEntry(byte[] oldkey, byte[] newkey)
        throws IOException, SQLException
    {
        try {
            doKey(oldkey, 1);
            doKey(newkey, 2);
        } finally {
            bc.close();
        }
    }

    public void addSelfRefEntry(byte[] oldkey, byte[] newkey,
                                byte[] oldfkey, byte[] newfkey)
        throws IOException
    {
        try {
            doKey(oldkey, 1);
            doKey(newkey, 2);
            doKey(oldfkey, 4);
            doKey(newfkey, 8);
        } finally {
            bc.close();
        }
    }

    public void finish(boolean abort) throws SQLException, IOException {
        try {
            if (!abort) {            
                bc.beforeFirst();
                while (bc.next()) {
                    if (bc.getVal(buf) == 1) {
                        if ((valid & (1 << buf[0])) != 0) {
                            ec.checkKeyRemoval(session, bc.getKey());
                        }
                    }
                }
            }
        } finally {
            try {
                if (bc != null) bc.release();
            } finally {
                bc = null;
                try {
                    if (index != null) index.free();
                } finally {
                    session.getDatabase().releaseTempFile();
                    index = null;
                    session = null;
                }
            }
        }
    }
        
    // must be after UpdateIndex to properly handle self ref foreign keys
    public int priority() { return 2; }

    /**
     * removal with cascade. NYI. XXX
     */
    public void removeKey(int refSpec, byte[] key) throws SQLException {
        if (refSpec == Constraint.CASCADE) {
        }
    }
}