simpletextdriver.java

codebook!

//----------------------------------------------------------------------------
//
// Module:      SimpleTextDriver.java
//
// Description: Implementation of the JDBC Driver interface
//
// Author:      Karl Moss
//
// Copyright:   (C) 1996,1997 Karl Moss.  All rights reserved.
//              You may study, use, modify and distribute this example
//              for any purpose, provided that this copyright notice
//              appears in all copies.  This example is provided WITHOUT
//              WARRANTY either expressed or implied.
//----------------------------------------------------------------------------

package jdbc.SimpleText;


//----------------------------------------------------------------------------
// The Java SQL framework allows for multiple database drivers.
//
// Each driver should supply a driver class that implements
// the Driver interface.
//
// The DriverManager will try to load as many drivers as it can
// find and then for any given connection request it will ask each
// driver in turn to try to connect to the target URL.
//
// It is strongly recommended that each Driver class should be
// small and standalone so that the Driver class can be loaded and
// queried without bringing in vast quantities of supporting code.
//
// When a Driver object is instantiated it should register itself
// with the SQL framework by calling DriverManager.registerDriver
//
// Note: Each driver must support a null constructor so it can be
// instantiated by doing:
//
//    java.sql.Driver d = Class.forName("foo.bah.Driver").newInstance();
//----------------------------------------------------------------------------
// NOTE - this is an implementation of the JDBC API version 1.20
//---------------------------------------------------------------------------

import java.sql.*;

public class SimpleTextDriver
    extends       SimpleTextObject
    implements    SimpleTextIDriver
{

    //------------------------------------------------------------------------
    // SimpleTextDriver
    // Constructor.  Attempt to register the JDBC driver
    //------------------------------------------------------------------------

    public SimpleTextDriver()
        throws SQLException
    {
        // Attempt to register this driver with the JDBC DriverManager.
        // If it fails, an exception will be thrown.

        DriverManager.registerDriver (this);
    }

    //------------------------------------------------------------------------
    // connect - JDBC API
    //
    // Try to make a database connection to the given URL.
    // The driver should return "null" if it realizes it is the wrong kind
    // of driver to connect to the given URL.  This will be common, as when
    // the JDBC driver manager is asked to connect to a given URL it passes
    // the URL to each loaded driver in turn.
    //
    // The driver should raise a SQLException if it is the right
    // driver to connect to the given URL, but has trouble connecting to
    // the database.
    //
    // The java.util.Properties argument can be used to passed arbitrary
    // string tag/value pairs as connection arguments.
    // Normally at least a "user" and "password" properties should be
    // included in the Properties.
    //
    //    url        The URL of the database to connect to
    //
    //    info    a list of arbitrary string tag/value pairs as
    //            connection arguments; normally at least a "user" and
    //            "password" property should be included
    //
    // Returns a Connection to the URL
    //------------------------------------------------------------------------

    public Connection connect(
        String url,
        java.util.Properties info)
        throws SQLException
    {
        if (traceOn()) {
            trace("@connect (url=" + url + ")");
        }

        // Ensure that we can understand the given url

        if (!acceptsURL(url)) {
            return null;
        }

        // Set the url for the driver

        driverURL = url;

        // For typical JDBC drivers, it would be appropriate to check
        // for a secure environment before connecting, and deny access
        // to the driver if it is deemed to be unsecure.  For the
        // SimpleText driver, if the environment is not secure we will
        // turn into a read-only driver.


        // Create a new SimpleTextConnection object

        SimpleTextConnection con = new SimpleTextConnection();


        // Initialize the new object

        con.initialize (this, info);

        return con;
    }

    //------------------------------------------------------------------------
    // acceptsURL - JDBC API
    //
    // Returns true if the driver thinks that it can open a connection
    // to the given URL.  Typically drivers will return true if they
    // understand the subprotocol specified in the URL and false if
    // they don't.
    //
    //    url        The URL of the database.
    //
    // Returns true if this driver can connect to the given URL.
    //------------------------------------------------------------------------

    public boolean acceptsURL(
        String url)
        throws SQLException
    {
        if (traceOn()) {
            trace("@acceptsURL (url=" + url + ")");
        }

        boolean rc = false;

        // Get the subname from the url.  If the url is not valid for
        // this driver, a null will be returned.

        if (getSubname(url) != null) {
            rc = true;
        }

        if (traceOn()) {
            trace(" " + rc);
        }
        return rc;
    }


    //------------------------------------------------------------------------
    // getPropertyInfo - JDBC API
    //
    // The getPropertyInfo method is intended to allow a generic GUI tool to
    // discover what properties it should prompt a human for in order to get
    // enough information to connect to a database.  Note that depending on
    // the values the human has supplied so far, additional values may become
    // necessary, so it may be necessary to iterate though several calls
    // to getPropertyInfo.
    //
    //    url        The URL of the database to connect to.
    //
    //    info    A proposed list of tag/value pairs that will be sent on
    //            connect open.
    //
    // Returns an array of DriverPropertyInfo objects describing possible
    //            properties.  This array may be an empty array if no properties
    //            are required.
    //------------------------------------------------------------------------

    public DriverPropertyInfo[] getPropertyInfo(
        String url,
        java.util.Properties info)
        throws SQLException
    {
        DriverPropertyInfo prop[];

        // Only one property required for the SimpleText driver; the
        // directory.  Check the property list coming in.  If the
        // directory is specified, return an empty list.

        if (info.getProperty("Directory") == null) {

            // Setup the DriverPropertyInfo entry

            prop = new DriverPropertyInfo[1];
            prop[0] = new DriverPropertyInfo("Directory", null);
            prop[0].description = "Initial text file directory";
            prop[0].required = false;

        }
        else {

            // Create an empty list

            prop = new DriverPropertyInfo[0];
        }

        return prop;
    }


    //------------------------------------------------------------------------
    // getMajorVersion - JDBC API
    //
    // Get the driver's major version number. Initially this should be 1.
    //------------------------------------------------------------------------

    public int getMajorVersion()
    {
        return SimpleTextDefine.MAJOR_VERSION;
    }

    //------------------------------------------------------------------------
    // getMinorVersion - JDBC API
    //
    // Get the driver's minor version number. Initially this should be 0.
    //------------------------------------------------------------------------

    public int getMinorVersion()
    {
        return SimpleTextDefine.MINOR_VERSION;
    }


    //------------------------------------------------------------------------
    // jdbcCompliant - JDBC API
    //
    // Report whether the Driver is a genuine JDBC COMPLIANT (tm) driver.
    // A driver may only report "true" here if it passes the JDBC compliance
    // tests, otherwise it is required to return false.
    //
    // JDBC compliance requires full support for the JDBC API and full support
    // for SQL 92 Entry Level.  It is expected that JDBC compliant drivers will
    // be available for all the major commercial databases.
    //
    // This method is not intended to encourage the development of non-JDBC
    // compliant drivers, but is a recognition of the fact that some vendors
    // are interested in using the JDBC API and framework for lightweight
    // databases that do not support full database functionality, or for
    // special databases such as document information retrieval where a SQL
    // implementation may not be feasible.
    //------------------------------------------------------------------------

    public boolean jdbcCompliant()
    {

        // The SimpleText driver is not JDBC compliant

        return false;
    }

    //------------------------------------------------------------------------
    // getSubname
    // Given a URL, return the subname.  Returns null if the protocol is
    // not 'jdbc' or the subprotocol is not 'simpletext'
    //------------------------------------------------------------------------

    public String getSubname()
    {
        return getSubname(driverURL);
    }

    public String getSubname(
        String url)
    {
        String subname = null;
        String protocol = "JDBC";
        String subProtocol = "SIMPLETEXT";

        // Convert to upper case and trim all leading and trailing
        // blanks

        url = (url.toUpperCase()).trim();

        // Make sure the protocol is jdbc:

        if (url.startsWith(protocol)) {

            // Strip off the protocol

            url = url.substring (protocol.length());

            // Look for the colon

            if (url.startsWith(":")) {
                url = url.substring(1);

                // Check the subprotocol

                if (url.startsWith (subProtocol)) {

                    // Strip off the subprotocol, leaving the subname

                    url = url.substring(subProtocol.length());

                    // Look for the colon that separates the subname
                    // from the subprotocol (or the fact that there
                    // is no subprotocol at all)

                    if (url.startsWith(":")) {
                        subname = url.substring(1);
                    }
                    else if (url.length() == 0) {
                        subname = "";
                    }
                }
            }
        }
        return subname;
    }


    //------------------------------------------------------------------------
    // getURL
    //
    // Get the URL specified for the driver
    //------------------------------------------------------------------------

    public String getURL()
    {
        return driverURL;
    }


    private String driverURL;
}