libjava/java/sql/DriverManager.java

   1 /* DriverManager.java -- Manage JDBC drivers
   2    Copyright (C) 1999, 2000, 2001 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38 package java.sql;
  39
  40 import java.io.PrintStream;
  41 import java.io.PrintWriter;
  42 import java.util.Enumeration;
  43 import java.util.Properties;
  44 import java.util.Vector;
  45 import java.util.StringTokenizer;
  46
  47 /**
  48   * This class manages the JDBC drivers in the system. It maintains a
  49   * registry of drivers and locates the appropriate driver to handle a
  50   * JDBC database URL.
  51   * <p>
  52   * On startup, <code>DriverManager</code> loads all the managers specified
  53   * by the system property <code>jdbc.drivers</code>.  The value of this
  54   * property should be a colon separated list of fully qualified driver
  55   * class names.  Additional drivers can be loaded at any time by
  56   * simply loading the driver class with <code>class.forName(String)</code>.
  57   * The driver should automatically register itself in a static
  58   * initializer.
  59   * <p>
  60   * The methods in this class are all <code>static</code>. This class
  61   * cannot be instantiated.
  62   *
  63   * @author Aaron M. Renn (arenn@urbanophile.com)
  64   */
  65 public class DriverManager
  66 {
  67   /**
  68    * This is the log stream for JDBC drivers.
  69    */
  70   private static PrintStream log_stream;
  71
  72   /**
  73    * This is the log writer for JDBC drivers.
  74    */
  75   private static PrintWriter log_writer;
  76
  77   /**
  78    * This is the login timeout used by JDBC drivers.
  79    */
  80   private static int login_timeout;
  81
  82   /**
  83    * This is the list of JDBC drivers that are loaded.
  84    */
  85   private static Vector drivers;
  86    // Hmm, seems like we might want to do a Hashtable and lookup by something,
  87    // but what would it be?
  88
  89   // Load all drivers on startup
  90   static
  91   {
  92     drivers = new Vector();
  93
  94     String driver_string = System.getProperty("jdbc.drivers");
  95     if (driver_string != null)
  96       {
  97         StringTokenizer st = new StringTokenizer(driver_string);
  98         while (st.hasMoreTokens())
  99           {
 100             String driver_classname = st.nextToken();
 101
 102             try
 103               {
 104                 Class.forName(driver_classname); // The driver registers itself
 105               }
 106             catch (Exception e) { ; } // Ignore not founds
 107           }
 108       }
 109
 110   }
 111
 112   /** Can't be instantiated. */
 113   private DriverManager()
 114   {
 115   }
 116
 117   /**
 118    * This method returns the log writer being used by all JDBC drivers.
 119    * This method should be used in place of the deprecated
 120    * <code>getLogStream</code> method.
 121    *
 122    * @return The log writer in use by JDBC drivers.
 123    */
 124   public static PrintWriter getLogWriter()
 125   {
 126     return log_writer;
 127   }
 128
 129   /**
 130    * This method sets the log writer being used by JDBC drivers.  This is a
 131    * system-wide parameter that affects all drivers.  Note that since there
 132    * is no way to retrieve a <code>PrintStream</code> from a
 133    * <code>PrintWriter</code>, this method cannot set the log stream in
 134    * use by JDBC.  Thus any older drivers may not see this setting.
 135    *
 136    * @param out The new log writer for JDBC.
 137    */
 138   public static void setLogWriter(PrintWriter out)
 139   {
 140     DriverManager.log_writer = out;
 141   }
 142
 143 /**
 144   * This method attempts to return a connection to the specified
 145   * JDBC URL string using the specified connection properties.
 146   *
 147   * @param url The JDBC URL string to connect to.
 148   * @param properties The connection properties.
 149   *
 150   * @return A <code>Connection</code> to that URL.
 151   *
 152   * @exception SQLException If an error occurs.
 153   */
 154   public static Connection getConnection(String url, Properties properties)
 155     throws SQLException
 156   {
 157     Driver d = getDriver(url);
 158     if (d == null)
 159       throw new SQLException("Driver not found for URL: " + url);
 160
 161     return d.connect(url, properties);
 162   }
 163
 164
 165   /**
 166    * This method attempts to return a connection to the specified
 167    * JDBC URL string using the specified username and password.
 168    *
 169    * @param url The JDBC URL string to connect to.
 170    * @param user The username to connect with.
 171    * @param password The password to connect with.
 172    * @return A <code>Connection</code> to that URL.
 173    * @exception SQLException If an error occurs.
 174    */
 175   public static Connection getConnection(String url, String user,
 176     String password) throws SQLException
 177   {
 178     Properties p = new Properties();
 179
 180     if (user != null)
 181       p.setProperty("user", user);
 182     if (password != null)
 183       p.setProperty("password", password);
 184
 185     return getConnection(url, p);
 186   }
 187
 188   /**
 189    * This method attempts to return a connection to the specified
 190    * JDBC URL string.
 191    *
 192    * @param url The JDBC URL string to connect to.
 193    *
 194    * @return A <code>Connection</code> to that URL.
 195    *
 196    * @exception SQLException If an error occurs.
 197    */
 198   public static Connection getConnection(String url) throws SQLException
 199   {
 200     return getConnection(url, new Properties());
 201   }
 202
 203   /**
 204    * This method returns a driver that can connect to the specified
 205    * JDBC URL string.  This will be selected from among drivers loaded
 206    * at initialization time and those drivers manually loaded by the
 207    * same class loader as the caller.
 208    *
 209    * @param url The JDBC URL string to find a driver for.
 210    *
 211    * @return A <code>Driver</code> that can connect to the specified
 212    * URL, or <code>null</code> if a suitable driver cannot be found.
 213    *
 214    * @exception SQLException If an error occurs.
 215    */
 216   public static Driver getDriver(String url) throws SQLException
 217   {
 218     // FIXME: Limit driver search to the appropriate subset of loaded drivers.
 219     Enumeration e = drivers.elements();
 220     while(e.hasMoreElements())
 221       {
 222         Driver d = (Driver)e.nextElement();
 223         if (d.acceptsURL(url))
 224           return d;
 225       }
 226
 227     return null;
 228   }
 229
 230   /**
 231    * This method registers a new driver with the manager.  This is normally
 232    * called by the driver itself in a static initializer.
 233    *
 234    * @param driver The new <code>Driver</code> to add.
 235    *
 236    * @exception SQLException If an error occurs.
 237    */
 238   public static void registerDriver(Driver driver) throws SQLException
 239   {
 240     if (! drivers.contains(driver))
 241       drivers.addElement(driver);
 242   }
 243
 244 /**
 245   * This method de-registers a driver from the manager.
 246   *
 247   * @param driver The <code>Driver</code> to unregister.
 248   *
 249   * @exception SQLException If an error occurs.
 250   */
 251   public static void deregisterDriver(Driver driver) throws SQLException
 252   {
 253     if (drivers.contains(driver))
 254       drivers.removeElement(driver);
 255   }
 256
 257   /**
 258    * This method returns a list of all the currently registered JDBC drivers
 259    * that were loaded by the current <code>ClassLoader</code>.
 260    *
 261    * @return An <code>Enumeration</code> of all currently loaded JDBC drivers.
 262    */
 263   public static Enumeration getDrivers()
 264   {
 265     Vector v = new Vector();
 266     Enumeration e = drivers.elements();
 267
 268     // Is this right?
 269     ClassLoader cl = Thread.currentThread().getContextClassLoader();
 270
 271     while(e.hasMoreElements())
 272       {
 273         Object obj = e.nextElement();
 274
 275         ClassLoader loader = obj.getClass().getClassLoader();
 276
 277         if (loader == null)
 278           loader = ClassLoader.getSystemClassLoader();
 279         if (! loader.equals(cl))
 280           continue;
 281
 282         v.addElement(obj);
 283       }
 284
 285     return v.elements();
 286   }
 287
 288   /**
 289    * This method set the login timeout used by JDBC drivers.  This is a
 290    * system-wide parameter that applies to all drivers.
 291    *
 292    * @param login_timeout The new login timeout value.
 293    */
 294   public static void setLoginTimeout(int seconds)
 295   {
 296     DriverManager.login_timeout = login_timeout;
 297   }
 298
 299   /**
 300    * This method returns the login timeout in use by JDBC drivers systemwide.
 301    *
 302    * @return The login timeout.
 303    */
 304   public static int getLoginTimeout()
 305   {
 306     return login_timeout;
 307   }
 308
 309   /**
 310    * This method sets the log stream in use by JDBC.
 311    *
 312    * @param log_stream The log stream in use by JDBC.
 313    *
 314    * @deprecated Use <code>setLogWriter</code> instead.
 315    */
 316   public static void setLogStream(PrintStream out)
 317   {
 318     DriverManager.log_stream = log_stream;
 319   }
 320
 321   /**
 322    * This method returns the log stream in use by JDBC.
 323    *
 324    * @return The log stream in use by JDBC.
 325    *
 326    * @deprecated Use <code>getLogWriter()</code> instead.
 327    */
 328   public static PrintStream getLogStream()
 329   {
 330     return log_stream;
 331   }
 332
 333   /**
 334    * This method prints the specified line to the log stream.
 335    *
 336    * @param str The string to write to the log stream.
 337    */
 338   public static void println(String message)
 339   {
 340     if (log_stream != null) // Watch for user not using logging
 341       log_stream.println(message);
 342   }
 343 }