package ModSQL;
import java.sql.*;
import java.util.Properties;

/* $Id: Driver.java,v 1.4 2004/01/03 17:54:11 cvs Exp $
 *
 * Copyright (c) 1999 Chris Studholme <chris.studholme@utoronto.ca>
 *
 * May be copied or modified under the terms of the GNU General Public
 * License.  See COPYING for more information.
 */

/**
 * <p>JDBC Driver object.
 *
 * <p>Automatically registers itself with the DriverManager when loaded.
 * To access this driver, use a url that starts with: 'jdbc:modsql'.
 *
 * @author chris.studholme@utoronto.ca
 */
public class Driver implements java.sql.Driver {

  /**
   * Attempt to register a new instance of this class with the
   * DriverManager.
   */
  static {
    try {
      DriverManager.registerDriver(new Driver());
    }
    catch (Exception e) {
      System.err.println("ModSQL.Driver: failed to initialize");
    }
  }

  /**
   * Default constructor.
   */
  public Driver() {
  }

  /**
   * Set the desired debug level.  Zero indicates no debug messages are
   * desired.  Larger values produce more messages.
   *
   * @param level non-negative debug level
   */
  public static void setDebugLevel(int level) {
    if (level<0)
      level=0;
    if (level>2)
      level=2;
    if (DriverConfig.debugLevel>0 || level>0)
      System.err.println("ModSQL.Driver: debugLevel set to "+level);
    DriverConfig.debugLevel=level;
  }

  /**
   * 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.
   *
   * <P>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.
   *
   * <P>The java.util.Properties argument can be used to passed arbitrary
   * string tag/value pairs as connection arguments.
   * Normally at least "user" and "password" properties should be
   * included in the Properties.
   *
   * @param url The URL of the database to connect to
   * @param info a list of arbitrary string tag/value pairs as
   * connection arguments; normally at least a "user" and
   * "password" property should be included
   * @return a Connection to the URL
   * @throws SQLException if a database-access error occurs.
   */
  public java.sql.Connection connect(String url, Properties info)
    throws SQLException {
    if (url.substring(0,11).equalsIgnoreCase("jdbc:modsql"))
      return new Connection();
    return null;
  }
  
  /**
   * 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.
   *
   * @param url The URL of the database.
   * @return True if this driver can connect to the given URL.  
   * @throws SQLException if a database-access error occurs.
   */
  public boolean acceptsURL(String url) throws SQLException {
    return (url.substring(0,11).equalsIgnoreCase("jdbc:modsql"));
  }
  
  
  /**
   * <p>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.
   *
   * @param url The URL of the database to connect to.
   * @param info A proposed list of tag/value pairs that will be sent on
   *          connect open.
   * @return An array of DriverPropertyInfo objects describing possible
   *          properties.  This array may be an empty array if no properties
   *          are required.
   * @throws SQLException if a database-access error occurs.
   */
  public java.sql.DriverPropertyInfo[] getPropertyInfo(String url, 
						       Properties info)
    throws SQLException {
    throw new SQLException("not implemented");
  }
  
  
  /**
   * Get the driver's major version number. 
   */
  public int getMajorVersion() {
    return DriverConfig.majorVersion;
  }
  
  /**
   * Get the driver's minor version number. 
   */
  public int getMinorVersion() {
    return DriverConfig.minorVersion;
  }
  
  
  /**
   * 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() {
    return false;
  }
} 

