ExportedKeyConstraint.java :  » Database-DBMS » Quadcap-Embeddable-Database » com » quadcap » sql » Java Open Source

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.index.Btree;
import com.quadcap.sql.index.BCursor;

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

/**
 * A hidden 'ExportedKeyConstraint' is created for tables that
 * are referenced as foreign keys by other tables.
 *
 * @author Stan Bailes
 */
public class ExportedKeyConstraint extends ForeignKeyConstraint
implements Externalizable
{
    transient ImportedKeyConstraint    iConstraint;
    transient String        iConstraintName;

    String          uConstraintName;
    

    /**
     * Default constructor
     */
    public ExportedKeyConstraint() {}

    /**
     * Explicit constructor for matching ImportedKeyConstraint.
     */
    public ExportedKeyConstraint(String name, Vector colNames,
         String fTableName, Vector fColNames,
         ImportedKeyConstraint iConstraint,
         UniqueConstraint uConstraint)
        throws SQLException
    {
  super(name, colNames, fTableName, fColNames);
  this.iConstraint = iConstraint;
  this.iConstraintName = iConstraint.getName();
  this.uConstraintName = uConstraint.getName();
        uConstraint.addExportConstraint(this);
        if (this.colNames == null) {
            this.colNames = uConstraint.getColumnNames();
        }
    }

    public void delete(Session session) throws SQLException, IOException {
  UniqueConstraint uc = 
      (UniqueConstraint)table.getConstraint(uConstraintName);
        if (uc != null) {
            uc.removeExportConstraint(name);
        }
    }

    void setForeignKeyCols(int[] fCols) {
  this.fCols = fCols;
    }
    
    public void checkUpdate(Session session, byte[] oldKey, Row row,
                            Row oldRow, long rowId, Constraint activeIndex)
  throws SQLException, IOException
    {
  getComparator();
  Database db = session.getDatabase();
  byte[] newKey = makeKey(session, row);
  if (activeIndex != this) oldKey = makeKey(session, oldRow);
  if (compare.compare(newKey, oldKey) != 0) {
      ExportedKeys ek = getExportedKeys(session);
      if (isSelfReferencing(db)) {
    byte[] oldfKey = makeFKey(session, oldRow);
    byte[] newfKey = makeFKey(session, row);
    ek.addSelfRefEntry(oldKey, newKey, oldfKey, newfKey);
      } else {
    ek.addEntry(oldKey, newKey);
      }
  }
    }
    
    public void checkDelete(Session session, Row row, long rowId)
  throws SQLException, IOException
    {
        byte[] fkey = getImportedKeyConstraint(session.getDatabase()).makeFKey(session, row);
  if (isSelfReferencing(session.getDatabase())) {
      ExportedKeys ek = getExportedKeys(session);
            byte[] key = makeKey(session, row);
        ek.addDeleteSelfRef(key, fkey);
  } else {
      checkKeyRemoval(session, fkey);
  }
    }

    public void checkKeyRemoval(Session session, byte[] oldkey) 
  throws SQLException, IOException
    {
  getComparator();
  Database db = session.getDatabase();
  Btree fTree = getForeignIndex(db);
  int count = 0;
        boolean match = false;
  BCursor cursor = fTree.getCursor(false);
        try {
            boolean kvalid = cursor.seek(oldkey);
            while (!match && (kvalid || cursor.next())) {
                byte[] key = cursor.getKey();
                int cmp = compare.compare(key, oldkey);
                match = cmp == 0;
                kvalid = false;
            }
        } finally {
            cursor.release();
        }
  if (match) {
      int refSpec = iConstraint.getRefAction(DELETE);
      switch (refSpec) {
      case NOACTION:
    throw new SQLException(
        "Foreign key constraint violation: children exist",
        "23000");

      case CASCADE:
    ExportedKeys ek = getExportedKeys(session);
    ek.removeKey(refSpec, oldkey);
    break;
      case SETNULL:
      case SETDEFAULT:
    // XXX TODO: set null, set default
                throw new SQLException(
        "Foreign key constraint violation and SET " +
        "{NULL|DEFAULT} not implemented", "23000");
      }
  }
    }
    
    /**
     * Utility function to get / lazy-create the session context used
     * to keep track of key additions and removals generated by the current
     * statement.
     */
    ExportedKeys getExportedKeys(Session session) throws IOException {
  ExportedKeys ek =
            (ExportedKeys)session.getContext(this, isDeferred());
  if (ek == null) {
      ek = new ExportedKeys(session, this);
      session.putContext(this, isDeferred(), ek);
  }
  return ek;
    }
    
    ImportedKeyConstraint getImportedKeyConstraint(Database db)
  throws SQLException, IOException
    {
  if (iConstraint == null) {
      getFTable(db);
      iConstraint =
    (ImportedKeyConstraint)fTable.getConstraint(iConstraintName);
  }
  return iConstraint;
    }

    Btree getForeignIndex(Database db) throws SQLException, IOException {
  return getImportedKeyConstraint(db).getIndex(db);
    }

    public void readExternal(ObjectInput in)
  throws IOException, ClassNotFoundException
    {
  super.readExternal(in);
  iConstraintName = (String)in.readObject();
  uConstraintName = (String)in.readObject();
    }
    
    public void writeExternal(ObjectOutput out) throws IOException {
  super.writeExternal(out);
  out.writeObject(iConstraintName);
  out.writeObject(uConstraintName);
    }
}