Quadcap Embeddable Database

com/quadcap/sql/TableOps.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.ArrayList;
import java.util.Enumeration;

import java.sql.SQLException;
import java.sql.Types;

import com.quadcap.sql.file.BlockFile;
import com.quadcap.sql.file.Datafile;
import com.quadcap.sql.file.PageManager;

import com.quadcap.sql.types.Value;
import com.quadcap.sql.types.ValueBlob;
import com.quadcap.sql.types.Type;

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

/**
 * 
 *
 * @author Stan Bailes
 */
public class TableOps {
    /**
     * Called to insert a new row on behalf of a session.
     */
    public static void insertRow(Session session, Table table, Row row)
        throws SQLException, IOException
    {
        session.getTableWriteLock(table.getName());
        int num = table.getNumConstraints();

        for (int i = 0; i < num; i++) {
            table.getConstraint(i).checkInsert(session, row);
        }

        if (table.hasBlobs()) {
            holdBlobsInRow(session, table, row);
        }
        
        InsertRow ins = new InsertRow(session, table, row);
        session.doStep(ins);
        long rowId = ins.getRowId();

        for (int i = 0; i < num; i++) {
            table.getConstraint(i).applyInsert(session, row, rowId, null);
        }

        //#ifdef DEBUG
        if (Trace.bit(14)) {
            Debug.println("insertRow(" + table.getName() + "): " +
                          row + " -> " + rowId);
        }
        //#endif
    }

    /**
     * Update an existing table row with integrity checking
     */
    public static void updateRow(Session session, Table table,
                                 byte[] key, long rowId, Row row,
                                 Constraint constraint)
        throws SQLException, IOException
    {
        session.getTableWriteLock(table.getName());
        //#ifdef DEBUG
        if (Trace.bit(14)) {
            Debug.println("updateRow(" + table.getName() + "): " +
                          row + " -> " + rowId);
        }
        //#endif

        Database db = session.getDatabase();
        BlockFile file = db.getFile();
        Row oldRow = table.getRow(db, rowId);
        int num = table.getNumConstraints();

        for (int i = 0; i < num; i++) {
            Constraint c = table.getConstraint(i);
            c.checkUpdate(session, key, row, oldRow, rowId, constraint);
        }

        if (table.hasBlobs()) {
            holdBlobsInRow(session, table, row);
            freeBlobsInRow(session, table, oldRow);
        }

        if (db.inMemory()) {
            // because we "know" that UpdateRow *doesn't* make a copy!
            row = new Row(row, table);
        }
        UpdateRow update = new UpdateRow(session, table, rowId, row);
        session.doStep(update) ;

        for (int i = 0; i < num; i++) {
            Constraint c = table.getConstraint(i);
            //Debug.println(c.getClass().getName() + ".applyUpdate");
            c.applyUpdate(session, key, row, oldRow, rowId, constraint);
        }
    }


    /**
     * Delete a row with integrity checking under control of a given
     * constraint.
     */
    public static void deleteRow(Session session, Table table,
                                 long rowId, Row row,
                                 Constraint constraint)
        throws SQLException, IOException
    {
        session.getTableWriteLock(table.getName());
        int num = table.getNumConstraints();

        for (int i = 0; i < num; i++) {
            Constraint c = table.getConstraint(i);
            c.checkDelete(session, row, rowId);
        }
        
        for (int i = 0; i < num; i++) {
            Constraint c = table.getConstraint(i);
            c.applyDelete(session, row, rowId, constraint);
        }       

        DeletedRows d =
            (DeletedRows)session.getContext("DeleteRow:" + table.getName(),
                                            false);
        if (d == null) {
            d = new DeletedRows(session, table);
            session.putContext("DeleteRow:" + table.getName(), false, d);
        }
        d.addEntry(rowId);

        //#ifdef DEBUG
        if (Trace.bit(14)) {
            Debug.println("deleteRow(" + table.getName() + "): " +
                          row + " -> " + rowId);
        }
        //#endif
    }

    public static Cursor getCursor(Session session, Relation t,
                                   SelectExpression select)
        throws SQLException
    {
        Cursor c = null;
        if (select != null) {
            c = select.getCursor(session, null);//ZZZ hot
        } else {
            c = t.getCursor(session, null, null, null);
        }
        return c;
    }

    /**
     * Hold references to any blobs in the row.
     */
    static final void holdBlobsInRow(Session session,
                                     Table tuple, Row row)
        throws SQLException, IOException 
    {
        if (tuple.hasBlobs()) {
            final long transId = session.getTransactionId();
            final Database db = session.getDatabase();
            for (int i = 1; i <= row.size(); i++) {
                Value v = row.item(i);
                Column col = tuple.getColumn(i);
                Type t = col.getType();
                if (isLargeObject(t)) {
                    
                    ValueBlob vb = null;
                    if (!(v instanceof ValueBlob)) {
                        v = t.convert(v);
                        row.set(i, v);
                    }
                    if (v instanceof ValueBlob) {
                        vb = (ValueBlob)v;
                    }
                    if (vb != null) {
                        if (vb.getBytesVal() != null) {
                            byte[] ff = vb.getBytesVal();
                            session.doStep(new InsertBlob(session, vb));
                        }
                        session.doStep(
                            new RefcountBlob(session, vb.getPermBlock(), 1));
                    }
                }
            }
        }
    }

    /**
     * Release any BLOB references held by this row.
     */
    static final void freeBlobsInRow(Session session, Table tuple, Row row)
        throws SQLException, IOException
    {
        if (row.getBlobCount() > 0) {
            for (int i = 1; i <= row.size(); i++) {
                Value v = row.item(i);
                Type t = v.getType();
                if (isLargeObject(t)) {
                    long transId = session.getTransactionId();
                    ValueBlob vb = (ValueBlob)v;
                    session.doStep(
                        new RefcountBlob(session, vb.getPermBlock(), -1));
                }
            }
        }
    }

    /**
     * Helper function to check for BLOB or CLOB types
     */
    static private final boolean isLargeObject(Type t) {
        final int type = t.getJDBCType();
        return type == Types.BLOB || type == Types.CLOB;
    }    

}