Quadcap Embeddable Database

com/quadcap/sql/Connection.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.SQLException;

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

import com.quadcap.sql.file.BlockFile;
import com.quadcap.sql.file.Log;

import com.quadcap.sql.lock.Lock;
import com.quadcap.sql.lock.LockMode;
import com.quadcap.sql.lock.Transaction;
import com.quadcap.sql.lock.TransactionObserver;

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

/**
 * Analagous (and mapped onto) a JDBC <code>Connection</code>, this class
 * maintains state and locks on behalf of a single session.
 *
 * @author Stan Bailes
 */
public class Connection implements TransactionObserver {
    Object                              connLock;
    Object                              fileLock;

    Transaction                         trans           = null;
    boolean                             transAborted    = false;
    long                                transId         = -1;
    
    String                              auth;
    boolean                             writeLog        = true;
    boolean                             autoCommit      = true;
    Database                            db;
    BlockFile                           file;
    Hashtable                           rlocks          = new Hashtable();
    Hashtable                           wlocks          = new Hashtable();

    Lock                                db_IS           = null;
    Lock                                db_IX           = null;

    Hashtable                           transContext            = null;
    Random                              random          = null;
    boolean                             readOnly        = false;

    List                                sessions        = new ArrayList();
    int                                 nextSession     = -1;
    boolean                             isClosed        = false;

    long                                lastInsertId    = -1;
   
    int                                 id;
    static int                          lastId          = 0;

    /**
     * Construct a new connection for the specified database with the specified
     * authorization
     *
     * @param db the database
     * @param user the authorization id
     * @param passwd the password
     *
     * @exception SQLException thrown if bad authorization
     */
    public Connection(Database db, String auth, String passwd)
        throws SQLException
    {
        this.id = lastId++;
        this.db = db;
        this.file = db.getFile();
        this.connLock = new Object();
        this.fileLock = file.getLock();
        this.readOnly = db.isReadOnly();
        setAuth(auth, passwd);
        //#ifdef TRACE
        if (Trace.bit(8)) {
            Debug.println("Connection() : " + this);
        }
        //#endif
    }

    /**
     * Create a new session and store it in the session table.
     */
    public final Session createSession() throws IOException, SQLException {
        int sessionPos = nextSession;
        if (nextSession == -1) {
            sessionPos = sessions.size();
            sessions.add(null);
        } else {
            nextSession = ((Number)sessions.get(nextSession)).intValue();
        }
        Session session = new Session(this, sessionPos);
        sessions.set(sessionPos, session);
        //Debug.println("createSession(" + sessionPos + "): " + Util.stackTrace());
        return session;
    }

    public final void removeSession(Session session) {
        if (sessions != null) {
            int pos = session.sessionIndex;
            Session sess2 = (Session)sessions.get(pos);
            if (sess2 != session) {
                throw new RuntimeException("Bad session table");
            }
            sessions.set(pos, new Integer(nextSession));
            nextSession = pos;
        }
    }

        final Session getSession(int i) {
//-        //#ifdef USE_WEAK_REFS2
//-        WeakReference ref = (WeakReference)sessions.elementAt(i);
//-        if (ref != null) {
//-            Object obj = ref.get();
//-            if (obj != null && obj instanceof Session) {
//-                return (Session)obj;
//-            }
//-        }
//-        return null;
        //#else
        Session s = null;
        Object obj = sessions.get(i);
        if (obj instanceof Session) s = (Session)obj;
        return s;
        //#endif
    }

    /**
     * Close all the sessions in the table
     */
    final void closeSessions() {
        for (int i = 0; i < sessions.size(); i++) {
            Session session = getSession(i);
            try {
                if (session != null) session.close();
            } catch (Throwable t) {
                //#ifdef DEBUG
                Debug.print(t);
                //#endif
            }
        }
        sessions = null;
        nextSession = -1;
    }

    /**
     * Given a SQL ID, attempt to generate a fully qualified name by
     * prepending the current schema name.
     *
     */
    final String resolveName(String name) {
        if (countDots(name) == 0 && auth != null && auth.length() > 0) {
            return auth + "." + name;
        } else {
            return name;
        }
    }

    /**
     * Return the number of '.' delimiters in this identifier,
     * skipping over any occurrences of '.' within delimted
     * identifiers (i.e., literal strings surrounded by double
     * quotes.)
     */
    static final int countDots(String name) {
        int cnt = 0;
        boolean quote = false;
        for (int i = 0; i < name.length(); i++) {
            char c = name.charAt(i);
            if (c == '"') quote = !quote;
            if (!quote && c == '.') cnt++;
        }
        return cnt;
    }

    /**
     * Return a fully qualified column name.
     *
     * Column:  <schema>.<table>.<column>
     */
    final String resolveColname(String name, Tuple cursorTuple) {
        String ret = name;
        switch (countDots(name)) {
        case 0:
            ret = cursorTuple.getName() + "." + name;
            if (ret.startsWith(".")) {
                ret = ret.substring(1);
            }
            break;
        case 1:
            if (auth != null && auth.length() > 0) {
                ret = auth + "." + name;
            }
            break;
        default:
        }
        return ret;
    }

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

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

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

    /**
     * Accessor for my 'Random' object
     */
    Random getRandom() {
        if (random == null) random = new Random();
        return random;
    }

    /**
     * The BLOB code (InsertBlob) needs access to the temp file.
     */
    final BlockFile getTempFile(boolean holdRef) throws IOException {
        return db.getTempFile(holdRef);
    }

    /**
     * At statement end, if autoCommit is TRUE, we commit (or rollback)
     * the transaction
     */
    void endStatement(Session session, boolean abort)
        throws IOException, SQLException
    {
        if (autoCommit && trans != null) {
            if (abort) {
                rollbackTransaction();
            } else {
                endTransaction();
            }
        }
    }            
            
    /**
     * Commit the current transaction
     *
     * PRE: cursors closed, statements finished.
     * POST: transaction commit/rollback, locks released
     */
    public final void endTransaction()
        throws IOException, SQLException
    {
        //#ifdef TRACE
        if (Trace.bit(9)) {
            Debug.println(toString() + ".endTransaction()");
        }
        //#endif
        SQLException se = null;
        IOException io = null;
        synchronized (fileLock) {
        synchronized (connLock) {
            try {
                if (transContext != null) {
                    try {
                        finishContexts();
                    } finally {
                        transContext = null;
                    }
                }
                if (!readOnly && trans != null) {
                    //#ifdef TRACE
                    if (Trace.bit(9)) {
                        Debug.println(toString() + ": db.commitTransaction()");
                    }
                    //#endif
                    try {
                        db.commitTransaction(trans);
                    } catch (Exception e) {
                        //#ifdef DEBUG
                        Debug.print(e);
                        //#endif
                        throw new RuntimeException(e.toString());
                    }
                }
            } catch (SQLException ex) {
                se = ex;
                checkAborted();
                db.rollbackTransaction(trans);
            } catch (IOException ex) {
                io = ex;
                checkAborted();
                db.rollbackTransaction(trans);
            } finally {
                releaseLocks();
            }
            if (se != null) throw se;
            if (io != null) throw io;
        }
        }
    }

    /**
     * Roll back this transaction. Toss the pending lists (and statement
     * contexts, right? XXX), close any cursors and get the database to
     * undo anything we've actually done to the database.
     */
    public final void rollbackTransaction()
        throws IOException, SQLException
    {
        //#ifdef TRACE
        if (Trace.bit(9)) {
            Debug.println(toString() + ".rollbackTransaction()");
        }
        //#endif
        synchronized (fileLock) {
        synchronized (connLock) {
            try {
                transContext = null;
                if (trans != null) {
                    db.rollbackTransaction(trans);
                }
            } finally {
                releaseLocks();
            }
        }
        }
    }

    /**
     * TransactionObserver implementation: abort the current transaction
     */
    public void abort(Transaction t) throws IOException {
        transContext = null;
        try {
            releaseLocks();
            db.releaseLocks(t);
        } finally {
            transAborted = true;
        }
    }

    /**
     * Statement rollback
     */
    final void rollbackStatement(Session s) throws IOException, SQLException {
        synchronized (fileLock) {
        synchronized (connLock) {
            checkAborted();
            if (trans != null) {
                db.rollbackStatement(trans, s.getStmtId());
            }
        }
        }
    }

    final void checkAborted() throws SQLException {
        synchronized (connLock) {
            if (transAborted) {
                transAborted = false;
                throw new SQLException("Transaction aborted");
            }
        }
    }

    /**
     * Return the current transaction
     */
    public final Transaction getTransaction() { return trans; }

    /**
     * Return the current transaction id as a long.
     */
    public final long getTransactionId() { return transId; }

    /**
     * Return (lazy create) the current Transaction
     */
    final Transaction makeTransaction() throws SQLException
    {
        if (trans == null) {
            synchronized (fileLock) {
            synchronized (connLock) {
                checkAborted();
                if (trans == null) {
                    try {
                        trans = db.makeTransaction(writeLog);
                    } catch (IOException ex) {
                        throw DbException.wrapThrowable(ex);
                    }
                    trans.setObserver(this);
                    transId = trans.getTransactionId();
                }
            }
            }
        }
        return trans;
    }

    /**
     * Get the database root lock in the specified mode.
     */
    final Lock getDbLock(int mode) throws IOException, SQLException {
        makeTransaction();
        switch (mode) {
        case LockMode.IS:
            if (db_IS == null) {
                synchronized (connLock) {
                    if (db_IS == null) {
                        db_IS = db.getLockManager().getLock(trans, null, "db", LockMode.IS);
                    }
                }
            }
            return db_IS;
        case LockMode.IX:
            if (db_IX == null) {
                synchronized (connLock) {
                    if (db_IX == null) {
                        db_IX = db.getLockManager().getLock(trans, null, "db", LockMode.IX);
                    }
                }
            }
            return db_IX;
        default:
            synchronized (connLock) {
                return db.getLockManager().getLock(trans, null, "db", mode);
            }
        }
    }

    /**
     * Helper routine to obtain a write lock on the specified table
     */
    final void getTableWriteLock(String tableName)
        throws SQLException, IOException
    {
        if (!readOnly && !inRecovery()) {
            synchronized (connLock) {
                if (wlocks.get(tableName) == null) {
                    Lock dbLock = getDbLock(LockMode.IX); 
                    db.getLockManager().getLock(trans, dbLock, tableName, LockMode.X);
                    wlocks.put(tableName, tableName);
                }
            }
        }
    }

    /**
     * Helper routine to obtain a read lock on the specified table
     */
    final void getTableReadLock(String tableName)
        throws SQLException, IOException
    {
        if (!readOnly && !inRecovery()) {
            synchronized (connLock) {
                if (rlocks.get(tableName) == null) {
                    Lock dbLock = getDbLock(LockMode.IS);
                    db.getLockManager().getLock(trans, dbLock, tableName, LockMode.S);
                    rlocks.put(tableName, tableName);
                }
            }
        }
    }

    /**
     * At transaction end, release our cached locks.
     * PRECONDITION: connLock monitor entered
     */
    final void releaseLocks() {
        if (!readOnly) {
            //#ifdef TRACE
            if (Trace.bit(9)) {
                Debug.println(toString() + ".releaseLocks()");
            }
            //#endif
            if (trans != null) {
                wlocks.clear();
                rlocks.clear();
                db_IS = null;
                db_IX = null;
                trans = null;
                transId = -1;
            }
        }
    }

    /**
     * Public setter for the 'autoCommit' flag.
     */
    public final void setAutoCommit(boolean b) {
        autoCommit = b;
    }

    /**
     * Public accessor for the 'autoCommit' flag.
     */
    public final boolean getAutoCommit() {
        return autoCommit;
    }

    /**
     * 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()
        throws SQLException, IOException 
    {
        SQLException se = null;
        IOException io = null;    

        int maxp = 0;
        for (int p = 0; p <= maxp; p++) {
            Enumeration keys = transContext.keys();
            while (keys.hasMoreElements()) {
                Object key = keys.nextElement();
                StatementContext sc = (StatementContext)transContext.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(false);
                    } catch (SQLException ex) {
                        se = ex;
                    } catch (IOException ex) {
                        io = ex;
                    }
                }
            }
        }
        if (se != null) throw se;
        if (io != null) throw io;
    }

    /**
     * Set the current authorization code
     */
    public final void setAuth(String auth, String passwd) throws SQLException {
        db.checkAuth(auth, passwd);
        this.auth = auth;
        this.writeLog = !auth.equals("__SYSTEM");
    }

    /**
     * Access to 'recovery' flag
     */
    final boolean inRecovery() throws IOException { return db.inRecovery(); }

    public final String getAuth() {
        return auth;
    }

    /**
     * Make a new (temporary) btree structure in the current database.
     */
    final Btree makeTempTree(Comparator compare) throws IOException {
        BlockFile f = db.getTempFile();
        long root = f.newPage();
        Btree tree = new Btree(f, compare, root, true);
        return tree;
    }

    final Btree makeTempTree() throws IOException {
        BlockFile f = db.getTempFile();
        long root = f.newPage();
        Btree tree = new Btree(f, root, true);
        return tree;
    }

    /**
     * Return a saved context
     */
    final StatementContext getContext(Object obj) {
        if (transContext == null) return null;
        return (StatementContext)transContext.get(obj);
    }

    /**
     * Add a new statement context
     */
    final void putContext(Object key, StatementContext val) {
        if (transContext == null) {
            transContext = new Hashtable();
        }
        transContext.put(key, val);
    }

    /**
     * Close this connection.  Close all statement sessions and end the
     * transaction.
     */
    public final void close() throws SQLException, IOException {
        //#ifdef TRACE
        if (Trace.bit(8)) {
            Debug.println(toString() + ".close()");
        }
        //#endif
        try {
            if (!readOnly) {
                try {
                    closeSessions();
                } finally {
                    if (trans != null) {
                        if (autoCommit) {
                            endTransaction();
                        } else {
                            rollbackTransaction();
                        }
                    }
                }
            }       
        } finally {
            isClosed = true;
            db.removeConnection();
        }
    }

    /**
     * Return true if this compare is closed
     */
    public boolean isClosed() {
        return isClosed || file == null;
    }

    /**
     * Return true if this connection is read-only
     */
    public boolean isReadOnly() {
        return readOnly;
    }

    //#ifdef DEBUG
    public String toString() {
        return "user=" + auth + ": (" + trans + ") " + db;
    }
    //#endif

    public String getLabel() {
        return "Connection " + id + ": (" + trans + ")";
    }

    long getLastInsertId() { return lastInsertId; }
    void setLastInsertId(long id) { lastInsertId = id; }
}