Quadcap Embeddable Database

com/quadcap/sql/Session.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.util.Hashtable;
import java.util.List;
import java.util.Random;

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

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

import com.quadcap.sql.file.BlockFile;
import com.quadcap.sql.file.ByteUtil;
import com.quadcap.sql.file.DatafileException;
import com.quadcap.sql.file.Log;
import com.quadcap.sql.file.LogEntry;

import com.quadcap.sql.lock.Transaction;

import com.quadcap.sql.io.ObjectOutputStream;

import com.quadcap.util.Debug;

/**
 * Analagous (and mapped onto) a JDBC <code>Statement</code>, this class
 * maintains state and locks on behalf of a single session.
 *
 * @author Stan Bailes
 */
public class Session {
    Connection                          qConn;
    Database                            db;
    ObjectOutputStream                  oos;
    
    ResultSet                           rs              = null;
    int                                 updateCount     = 0;
    long                                lastInsertId    = 0;

    Object                              plock           = new Object();
    List                                stmtPendingActions      = null;
    
    List                                cursors         = null;
    Hashtable                           stmtContext     = null;
    int                                 stmtId          = 0;

    /** my position in qConn.sessions */
    int                                 sessionIndex    = -1;
    static int                          lastId          = 0;

    boolean                             viewCheck       = false;
    public boolean getViewCheck() { return viewCheck; }
    public void setViewCheck() { viewCheck = true; }
    public void clearViewCheck() { viewCheck = false; }

    /**
     * Construct a new session for the specified database with the specified
     * authorization
     *
     * @param db the database
     * @param auth the authorization id
     */
    Session(Connection conn, int sessionIndex) {
        this.qConn = conn;
        this.sessionIndex = sessionIndex;
        this.db = conn.getDatabase();
        //this.id = lastId++;
        this.lastInsertId = conn.getLastInsertId();
        this.oos = new ObjectOutputStream(null);
    }

    /**
     * Accessor for my connection
     */
    public final Connection getConnection() { return qConn; }

    /**
     * Accessor for my transaction (lazy)
     */
    public final Transaction getTransaction() {
        return qConn.getTransaction();
    }
    
    /**
     * Accessor for my transaction id (lazy)
     */
    public final long getTransactionId() {
        return qConn.getTransactionId();
    }

    /**
     * Return the transaction id, starting a new transaction if
     * necessary
     */
    public final long makeTransaction() throws SQLException {
        long trans = getTransactionId();
        if (trans < 0) {
            qConn.makeTransaction();
            trans = qConn.getTransactionId();
            stmtId = 0;
        } else {
            stmtId++;
        }
        return trans;
    }

    /**
     * Accessor for my logger
     */
    final public Log getLog() { return db.getLog(); }

    /**
     * Return my session id
     */
    public int getSessionId() { return sessionIndex; }

    /**
     * Return the current statement number
     */
    public int getStmtId() { return stmtId; }

    /**
     * Create a temporary btree with the specified comparator
     */
    final Btree makeTempTree(Comparator compare) throws IOException {
        return qConn.makeTempTree(compare);
    }

    /**
     * Create a temporary btree with the default comparator
     */
    final Btree makeTempTree() throws IOException {
        return qConn.makeTempTree();
    }

    /**
     * Accessor for my database
     */
    public final Database getDatabase() { return db; }

    /**
     * Accessor for my file
     */
    public final BlockFile getFile() { return qConn.getFile(); }

    /**
     * Accessor for my 'Random' object
     */
    final Random getRandom() { return qConn.getRandom(); }

    /**
     * Helper routine to obtain a write lock on the specified table
     */
    public final void getTableWriteLock(String tableName)
        throws SQLException, IOException
    {
        qConn.getTableWriteLock(tableName);
    }

    /**
     * Helper routine to obtain a read lock on the specified table
     */
    public final void getTableReadLock(String tableName)
        throws SQLException, IOException
    {
        qConn.getTableReadLock(tableName);
    }

    /**
     * When a statement is initiated on a connection, any previous
     * result set open on that connection is implicitly closed.
     */
    final void closeResultSet() {
        //#ifdef TRACE
        if (Trace.bit(9)) {
            Debug.println(toString() + ".closeResultSet()");
        }
        //#endif
        if (rs != null) {
            try {
                rs.close();
            } catch (Throwable t) {
                //#ifdef DEBUG
                //Debug.print(t);
                //#endif
            } finally {
                rs = null;
            }
        }
    }

    /**
     * Execute a single SQL statement.
     */
    public final void doStatement(Stmt s) throws IOException, SQLException {
        // ---- If the last statement had a result set, then commit
        // ---- it (if auto commit) and close the result set.  This is
        // ---- mandated by JDBC.

        //#ifdef TRACE
        if (Trace.bit(9)) {
            Debug.println(toString() + ".doStatement(" + s + ")");
        }
        //#endif
        
        if (rs != null) {
            closeResultSet();
        }
        makeTransaction();
        if (qConn.readOnly) {
            if (!(s instanceof SelectStmt)) {
                throw new SQLException(
                    "Only SELECT statements are permitted in read-only mode");
            }
            s.execute(this);
        } else {
            updateCount = 0;
            beginStatement();

            try {
                s.execute(this);
            } catch (IOException e) {
                //#ifdef DEBUG
                Debug.print(e);
                //#endif
                rollbackStatement();
                throw e;
            } catch (SQLException e) {
                //#ifdef DEBUG
                if (Trace.bit(1)) {
                    Debug.println("--- Verbose exception report: ");
                    Debug.print(e);
                }
                //#endif
                rollbackStatement();
                throw e;
            } catch (Throwable e) {
                //#ifdef DEBUG
                Debug.print(e);
                //#endif
                rollbackStatement();
                throw DbException.wrapThrowable(e);
            }

            // ---- If no result set, then just commit (statement or
            // ---- transaction level as required) now.
            if (rs == null) {
                endStatement(false);
            }
        }
    }

    public final void beginStatement() throws IOException {
        getLog().addEntry(new LogEntry(getTransactionId(), stmtId,
                                       LogEntry.BEGIN_STATEMENT));
    }
    
    /**
     * Called to conclude the execution of this statement.
     *
     * @param abort if <b>true</b>, we perform statement-level
     * rollback, otherwise we conclude the statement (possibly
     * committing the results if autoCommit is <b>true</b>.
     */
    public final void endStatement(boolean abort)
        throws IOException, SQLException
    {
        //#ifdef TRACE
        if (Trace.bit(9)) {
            Debug.println(toString() + ".endStatement(" + abort + ")");
        }
        //#endif
        if (getTransactionId() >= 0) {
            try {
                closeCursors(abort);
            } catch (SQLException e) {
                rollbackStatement();
                throw e;
            }
            qConn.endStatement(this, abort);
        }
    }

    /**
     * Close any open cursors, aborting or commiting the current transaction
     */
    final void closeCursors(boolean abort) 
        throws SQLException, IOException 
    {
        if (cursors != null) {
            for (int i = 0; i < cursors.size(); i++) {
                Cursor c = (Cursor)cursors.get(i);
                c.close();
            }
            cursors = null;
        }
        if (abort) {
            stmtPendingActions = null;
        } else {
            doPendingActions();
        }
        if (stmtContext != null) {
            try {
                finishContexts(stmtContext, abort);
            } finally {
                stmtContext = null;
            }
        }
    }

    /**
     * Statement-level abort.  The current statement has failed, but the
     * transaction as a whole is still ongoing, so only the effects of
     * the current statement so far should be undone.
     */
    final void rollbackStatement() throws IOException, SQLException {
        //#ifdef TRACE
        if (Trace.bit(9)) {
            Debug.println(toString() + ".rollbackStatement()");
        }
        //#endif
        synchronized (plock) {
            stmtPendingActions = null;
        }
        qConn.rollbackStatement(this);
    }

    
    /**
     * Log and execute the given unit of work for this session
     */
    public final void doStep(LogStep s) throws SQLException, IOException {
        synchronized (db.getFileLock()) {
            s.prepare(this);
            //#ifdef DEBUG
            if (false && Trace.bit(15)) {
                Debug.println("[T:" + qConn.getTransactionId() +
                              "].redo(" + s + ")");
            }
            //#endif
            try {
                db.doStep(getTransaction(), s);
            } catch (DatafileException e) {
                //#ifdef DEBUG
                //Debug.print(e);
                //#endif
                throw (SQLException)e.getCause();
            }
        }
    }

    final void setResultSet(QedResultSet rs) {
        this.rs = rs;
    }

    /**
     * Return the result set associated with this session
     */
    final ResultSet getResultSet() {
        return rs;
    }

    /**
     * Return the result set associated with this session, after
     * making sure that the the result set is bound to my Statement!
     */
    public final ResultSet getResultSet(Statement stmt) {
        getResultSet();
        if (rs != null) ((QedResultSet)rs).setStatement(stmt);
        return rs;
    }

    /**
     * Return the session update count
     */
    public final int getUpdateCount() {
        return updateCount;
    }

    final void setUpdateCount(int c) {
        this.updateCount = c;
    }

    final void incrUpdateCount() {
        this.updateCount++;
    }

    final void decrUpdateCount() {
        this.updateCount++;
    }

    /**
     * An action to be executed once the currently open cursors are
     * closed.
     */
    final void addPendingAction(LogStep action) {
        synchronized (plock) {
            if (stmtPendingActions == null) stmtPendingActions = new ArrayList();
            stmtPendingActions.add(action);
        }
    }


    /**
     * At transaction end, execute all of the pending actions
     */
    final void doPendingActions() throws SQLException, IOException {
        synchronized (plock) {
            if (stmtPendingActions != null) {
                for (int i = 0; i < stmtPendingActions.size(); i++) {
                    LogStep step = (LogStep)stmtPendingActions.get(i);
                    doStep(step);
                }
                stmtPendingActions = null;
            }
        }
    }

    /**
     * Another cursor created for this session, which we need to keep
     * track of.
     */
    final void addCursor(Cursor c) {
        if (cursors == null) {
            cursors = new ArrayList();
        }
        cursors.add(c);
    }
   
    /**
     * Each context object represents some state retained on behalf
     * of a constraint.  The 'finish()' method of the context is used
     * to perform any constraint-specific processing at the end of
     * a statement/transaction.
     */
    final void finishContexts(Hashtable context, boolean abort)
        throws SQLException, IOException 
    {
        SQLException se = null;
        IOException io = null;    

        int maxp = 0;
        for (int p = 0; p <= maxp; p++) {
            Enumeration keys = context.keys();
            while (keys.hasMoreElements()) {
                Object key = keys.nextElement();
                StatementContext sc = (StatementContext)context.get(key);
                int sp = sc.priority();
                maxp = Math.max(maxp, sp);
                if (sp == p) {
                    try {
                        //#ifdef TRACE
                        if (Trace.bit(10)) {
                            Debug.println(toString() + " Finish " +
                                          Table.strip(sc.getClass().getName()));
                        }
                        //#endif
                        sc.finish(abort);
                    } catch (SQLException ex) {
                        se = ex;
                    } catch (IOException ex) {
                        io = ex;
                    }
                }
            }
        }
        if (se != null) throw se;
        if (io != null) throw io;
    }

    /**
     * Return the requested statement context.
     *
     * @param obj is the key which uniquely identifies the context
     * @param deferrable is <b>true</b> if this context's execution can
     *          be deferred until after the current statement.
     */
    final StatementContext getContext(Object obj,
                                      boolean deferrable) {
        StatementContext ret = null;        
        if (deferrable) {
            ret = qConn.getContext(obj);
        } else if (stmtContext != null) {
            ret = (StatementContext)stmtContext.get(obj);
        }
        return ret;
    }

    /**
     * Add a new context...
     */
    final void putContext(Object key, boolean deferrable,
                          StatementContext val) {
        if (deferrable) {
            qConn.putContext(key, val);
        } else {
            if (stmtContext == null) {
                stmtContext = new Hashtable();
            }
            stmtContext.put(key, val);
        }
    }

    /**
     * Close this session
     */
    public final void close() throws SQLException, IOException {
        endStatement(false);
        qConn.removeSession(this);
    }

    /**
     * Set the session's "LAST INSERT ID"
     */
    final void setLastInsertId(long insid) {
        lastInsertId = insid;
        qConn.setLastInsertId(insid);
    }

    /**
     * Return the session's "LAST INSERT ID"
     */
    public long getLastInsertId() {
        return lastInsertId;
    }

    //#ifdef DEBUG
    /**
     * Return a string representation for debugging
     */
    public String toString() {
        return "Session " + sessionIndex + ": " + qConn;
    }
    //#endif

    /**
     * A buffer private to this session for formatting rowIds
     */
    byte[] buf8 = new byte[8];
    public final byte[] getBuf8(long l) {
        ByteUtil.putLong(buf8, 0, l);
        return buf8;
    }

    public boolean inRecovery() throws IOException {
        return qConn.inRecovery();
    }
}