Quadcap Embeddable Database

com/quadcap/jdbc/JdbcDriver.java

Go to the documentation of this file.

package com.quadcap.jdbc;

/* 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.File;
import java.io.IOException;

import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Properties;
import java.util.Vector;

import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.DriverPropertyInfo;
import java.sql.SQLException;

import com.quadcap.sql.Cursor;
import com.quadcap.sql.Database;
import com.quadcap.sql.QedResultSet;
import com.quadcap.sql.QDriver;
import com.quadcap.sql.Session;
import com.quadcap.sql.Version;

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

/**
 * This class implements the <code>java.sql.Driver</code> interface,
 * which provides a basic mechanism for establishing connections to
 * a QED database.  A driver can support multiple simultaneously open
 * databases -- the database URL specifies a file name which is the
 * root directory of the database, and which is used to select the
 * correct database.
 *
 * @author Stan Bailes
 */
public class JdbcDriver implements QDriver {
    /*{com.quadcap.qed.Trace-vars.xml-0}
     *
     * <config>
     */

    /*{com.quadcap.qed.Trace-vars.xml-999999}
     *
     * </config>
     */

    /*{com.quadcap.qed.Trace-vars.xml-1050}
     * <config-var>
     *   <config-name>qed.trace.JdbcDriver</config-name>
     *   <config-dflt>0</config-dflt>
     *   <config-desc>
     *   <pre>
     *     bit 0: API execution
     *     bit 1: Database open/close
     *    </pre>
     *    </config-desc>
     * </config-var>
     */
    //#ifdef DEBUG
    static final ConfigNumber   trace =
    ConfigNumber.find("qed.trace.JdbcDriver", "0");
    //#endif
    
    static Hashtable                    dbs             = new Hashtable();

    public static JdbcDriver            jdbcDriver      = null;

    static {
        try {
            DriverManager.registerDriver(jdbcDriver = new JdbcDriver());
        } catch (SQLException e) {
            Debug.print(e);
        }
    }

    /**
     * No-argument constructor
     */
    public JdbcDriver() {
    }
    
    /**
     * Make a new <code>Connection</code> for the specified database
     * and user.
     * @deprecated <i>Pay no attention to that man behind the curtains.</i>
     *
     * @param db the database
     * @param auth the userid
     */
    public java.sql.Connection makeConnection(Database db, String auth,
                                              String passwd)
        throws SQLException
    {
        //#ifdef DEBUG
        if (trace.bit(0)) {
            Debug.println("JdbcDriver.makeConnection()");
        }
        //#endif
        return new Connection(db, auth, passwd);
    }

    /**
     * Make a <code>QedResultSet</code> to wrap the internal database
     * cursor.
     * @deprecated <i>Pay no attention to that man behind the curtains.</i>
     * 
     * @param c the cursor
     * @return the resultset
     */
    public QedResultSet makeResultSet(Cursor c) {
        return new ResultSet(c);
    }

    /**
     * Return true if this is a QED JDBC URL.  QED URLS are of the
     * form <code>jdbc:qed:<i>database</i></code>.
     *
     * @param url a URL
     * @return true if <code>url</code> is a QED JDBC URL.
     */
    public boolean acceptsURL(String url) {
        if (url.startsWith("jdbc:")) {
            url = url.substring(5);
            int idx = url.indexOf(':');
            if (idx > 0) {
                String protocol = url.substring(0, idx);
                if (protocol.equals("quadcap")) return true;
                if (protocol.equals("qed")) return true;
            }
        }
        return false;
    }

    /**
     * Assuming that <code>url</code> is a QED URL, return a new
     * <code>Connection</code> object that can be used to access the
     * database specified by that url. 
     *
     * @param url a JDBC URL.  If the URL string contains a semicolon,
     *     then the URL proper is interpreted as the portion of the
     *     string preceeding the semicolon, and the remaining string
     *     is treated as a semi-colon separated list of 'name=value'
     *     connection properties.  E.g., <code>jdbc:qed:db1;create=true</code>
     *
     * @param props a set of connection properties.
     * @return a new Connection
     * @exception SQLException may be thrown
     */
    public java.sql.Connection connect(String url, Properties props)
        throws SQLException
    {
        //#ifdef DEBUG
        if (trace.bit(0)) {
            Debug.println("JdbcDriver.connect(" + url + ", " + props + ")");
        }
        //#endif
        if (!acceptsURL(url)) return null;
        String origUrl = url;
        url = url.substring(5);
        int idx = url.indexOf(';');
        if (idx >= 0) {
            String extraProps = url.substring(idx+1);
            url = url.substring(0, idx);
            Properties props2 = new Properties(Config.getPropSubset("qed.*"));
            props2.putAll(props);
            props2.putAll(Util.parsePropsString(extraProps));
            props = props2;
        }

        idx = url.indexOf(':');
        String param = url.substring(idx+1);
        
        Database db = null;
        try {
            param = new File(param).getCanonicalPath();
            synchronized (dbs) {
                db = (Database)dbs.get(param);
                if (db == null) {
                    //#ifdef DEBUG
                    if (trace.bit(1)) {
                        Debug.println("Open database " + dbs.size() + ": " + param);
                    }
                    //#endif
                    db = new Database();
                    db.init(this, origUrl, param, props);
                    db.driverLock = dbs;
                    dbs.put(param, db);
                }
                db.addConnection();
            }
        } catch (IOException e) {
            Debug.print(e);
            throw new SQLException(e.toString(), "Q000Z");
        }
        
        String auth = props.getProperty("user");
        String pass = props.getProperty("passwd");
        Connection conn = null;
        try {
            conn = new Connection(db, auth, pass);
        } finally {
            // in case an (auth?) exception is thrown, we need to avoid
            // leaking the connection.
            if (conn == null) {
                synchronized (dbs) {
                    db.removeConnection();
                }
            }
        }
        return conn;
    }

    /**
     * Return the driver major version number.
     *
     * @return the driver's major version number
     */
    public int getMajorVersion() { return Version.majorVersion; }

    /**
     * Return the driver minor version number.
     *
     * @return the driver's minor version number
     */
    public int getMinorVersion() { return Version.minorVersion; }
    
    /**
     * Return an array of <code>DriverPropertyInfo</code> objects
     * that describe the properties required to connect to a 
     * QED database.  Currently no properties are required except
     * <code>user</code>
     *
     * @param url the database url
     * @param info the properties the client has so far.
     * @return the required connect properties
     */
    public DriverPropertyInfo[] getPropertyInfo(String url,
                                                Properties info)
        throws SQLException
    {
        int cnt = 0;
        if (info == null || info.get("user") == null) cnt++;
        DriverPropertyInfo[] ret = new DriverPropertyInfo[cnt];
        if (cnt != 0) {
            ret[0] = new DriverPropertyInfo("user", null);
            ret[0].required = true;
        }
        return ret;
    }
    
    /**
     * QED is a JDBC compliant driver
     *
     * @return true
     */
    public boolean jdbcCompliant() {
        return true;            // since 3.1, we're declaring success...
    }

    /**
     * Close the specified database.
     * @deprecated <i>Pay no attention to that man behind the curtains.</i>
     *
     * @param name the name of the database.
     */
    public void closeDatabase(final String name) {
        //#ifdef DEBUG
        if (trace.bit(1)) {
            Debug.println("closeDatabase(" + name + ")");
        }
        //#endif
        synchronized (dbs) {
            Database db = (Database)dbs.get(name);
            if (db != null) {
                try {
                    db.close();
                } finally {
                    dbs.remove(name);
                }
            }
        }
        //#ifdef DEBUG
        if (trace.bit(1)) {
            Debug.println("closeDatabase(" + name + ") complete");
        }
        //#endif
    }
        
    /**
     * Enumerate the currently open databases
     * @deprecated <i>Pay no attention to that man behind the curtains.</i>.
     *
     * @return an enumeration of the names of the currently open databases
     */
    public Enumeration getDatabaseNames() {
        return dbs.keys();
    }
    
    /**
     * Locate a specific database by name
     * @deprecated <i>Pay no attention to that man behind the curtains.</i>.
     *
     * @param name the name of the database
     * @return the database.
     */
    public Database getDatabase(String name) {
        synchronized (dbs) {
            return (Database)dbs.get(name);
        }
    }
    
    /**
     * Close all databases (presumably at program exit)
     */
    public static void closeAll() {
        synchronized (dbs) {
            Enumeration e = JdbcDriver.dbs.elements();
            while (e.hasMoreElements()) {
                Database db = (Database)e.nextElement();
                try {
                    db.close();
                } catch (Throwable t) {
                }
            }
            dbs.clear();
        }
    }

    /**
     * Return the session for this connection
     */
    public Session getSession(java.sql.Connection conn) {
        try {
            QDriver d = (QDriver)DriverManager.getDriver("jdbc:qed");
            return d.getSession(conn);
        } catch (SQLException ex) {
            return null;
        }
    }
}