libjava/java/sql/DriverManager.java

   1 /* DriverManager.java -- Manage JDBC drivers
   2    Copyright (C) 1999, 2000, 2001, 2003 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)
 107               {
 108                 // Ignore not founds
 109               }
 110           }
 111       }
 112
 113   }
 114
 115   /** Can't be instantiated. */
 116   private DriverManager()
 117   {
 118   }
 119
 120   /**
 121    * This method returns the log writer being used by all JDBC drivers.
 122    * This method should be used in place of the deprecated
 123    * <code>getLogStream</code> method.
 124    *
 125    * @return The log writer in use by JDBC drivers.
 126    */
 127   public static PrintWriter getLogWriter()
 128   {
 129     return log_writer;
 130   }
 131
 132   /**
 133    * This method sets the log writer being used by JDBC drivers.  This is a
 134    * system-wide parameter that affects all drivers.  Note that since there
 135    * is no way to retrieve a <code>PrintStream</code> from a
 136    * <code>PrintWriter</code>, this method cannot set the log stream in
 137    * use by JDBC.  Thus any older drivers may not see this setting.
 138    *
 139    * @param out The new log writer for JDBC.
 140    */
 141   public static void setLogWriter(PrintWriter out)
 142   {
 143     DriverManager.log_writer = out;
 144   }
 145
 146 /**
 147   * This method attempts to return a connection to the specified
 148   * JDBC URL string using the specified connection properties.
 149   *
 150   * @param url The JDBC URL string to connect to.
 151   * @param properties The connection properties.
 152   *
 153   * @return A <code>Connection</code> to that URL.
 154   *
 155   * @exception SQLException If an error occurs.
 156   */
 157   public static Connection getConnection(String url, Properties properties)
 158     throws SQLException
 159   {
 160     Driver d = getDriver(url);
 161     if (d == null)
 162       throw new SQLException("Driver not found for URL: " + url);
 163
 164     return d.connect(url, properties);
 165   }
 166
 167
 168   /**
 169    * This method attempts to return a connection to the specified
 170    * JDBC URL string using the specified username and password.
 171    *
 172    * @param url The JDBC URL string to connect to.
 173    * @param user The username to connect with.
 174    * @param password The password to connect with.
 175    * @return A <code>Connection</code> to that URL.
 176    * @exception SQLException If an error occurs.
 177    */
 178   public static Connection getConnection(String url, String user,
 179     String password) throws SQLException
 180   {
 181     Properties p = new Properties();
 182
 183     if (user != null)
 184       p.setProperty("user", user);
 185     if (password != null)
 186       p.setProperty("password", password);
 187
 188     return getConnection(url, p);
 189   }
 190
 191   /**
 192    * This method attempts to return a connection to the specified
 193    * JDBC URL string.
 194    *
 195    * @param url The JDBC URL string to connect to.
 196    *
 197    * @return A <code>Connection</code> to that URL.
 198    *
 199    * @exception SQLException If an error occurs.
 200    */
 201   public static Connection getConnection(String url) throws SQLException
 202   {
 203     return getConnection(url, new Properties());
 204   }
 205
 206   /**
 207    * This method returns a driver that can connect to the specified
 208    * JDBC URL string.  This will be selected from among drivers loaded
 209    * at initialization time and those drivers manually loaded by the
 210    * same class loader as the caller.
 211    *
 212    * @param url The JDBC URL string to find a driver for.
 213    *
 214    * @return A <code>Driver</code> that can connect to the specified
 215    * URL.
 216    *
 217    * @exception SQLException If an error occurs, or no suitable driver can be found.
 218    */
 219   public static Driver getDriver(String url) throws SQLException
 220   {
 221     // FIXME: Limit driver search to the appropriate subset of loaded drivers.
 222     Enumeration e = drivers.elements();
 223     while(e.hasMoreElements())
 224       {
 225         Driver d = (Driver)e.nextElement();
 226         if (d.acceptsURL(url))
 227           return d;
 228       }
 229
 230     throw new SQLException("No driver found for " + url);
 231   }
 232
 233   /**
 234    * This method registers a new driver with the manager.  This is normally
 235    * called by the driver itself in a static initializer.
 236    *
 237    * @param driver The new <code>Driver</code> to add.
 238    *
 239    * @exception SQLException If an error occurs.
 240    */
 241   public static void registerDriver(Driver driver) throws SQLException
 242   {
 243     if (! drivers.contains(driver))
 244       drivers.addElement(driver);
 245   }
 246
 247 /**
 248   * This method de-registers a driver from the manager.
 249   *
 250   * @param driver The <code>Driver</code> to unregister.
 251   *
 252   * @exception SQLException If an error occurs.
 253   */
 254   public static void deregisterDriver(Driver driver) throws SQLException
 255   {
 256     if (drivers.contains(driver))
 257       drivers.removeElement(driver);
 258   }
 259
 260   /**
 261    * This method returns a list of all the currently registered JDBC drivers
 262    * that were loaded by the current <code>ClassLoader</code>.
 263    *
 264    * @return An <code>Enumeration</code> of all currently loaded JDBC drivers.
 265    */
 266   public static Enumeration getDrivers()
 267   {
 268     Vector v = new Vector();
 269     Enumeration e = drivers.elements();
 270
 271     // Is this right?
 272     ClassLoader cl = Thread.currentThread().getContextClassLoader();
 273
 274     while(e.hasMoreElements())
 275       {
 276         Object obj = e.nextElement();
 277
 278         ClassLoader loader = obj.getClass().getClassLoader();
 279
 280         if (loader == null)
 281           loader = ClassLoader.getSystemClassLoader();
 282         if (! loader.equals(cl))
 283           continue;
 284
 285         v.addElement(obj);
 286       }
 287
 288     return v.elements();
 289   }
 290
 291   /**
 292    * This method set the login timeout used by JDBC drivers.  This is a
 293    * system-wide parameter that applies to all drivers.
 294    *
 295    * @param login_timeout The new login timeout value.
 296    */
 297   public static void setLoginTimeout(int seconds)
 298   {
 299     DriverManager.login_timeout = login_timeout;
 300   }
 301
 302   /**
 303    * This method returns the login timeout in use by JDBC drivers systemwide.
 304    *
 305    * @return The login timeout.
 306    */
 307   public static int getLoginTimeout()
 308   {
 309     return login_timeout;
 310   }
 311
 312   /**
 313    * This method sets the log stream in use by JDBC.
 314    *
 315    * @param log_stream The log stream in use by JDBC.
 316    *
 317    * @deprecated Use <code>setLogWriter</code> instead.
 318    */
 319   public static void setLogStream(PrintStream out)
 320   {
 321     DriverManager.log_stream = log_stream;
 322   }
 323
 324   /**
 325    * This method returns the log stream in use by JDBC.
 326    *
 327    * @return The log stream in use by JDBC.
 328    *
 329    * @deprecated Use <code>getLogWriter()</code> instead.
 330    */
 331   public static PrintStream getLogStream()
 332   {
 333     return log_stream;
 334   }
 335
 336   /**
 337    * This method prints the specified line to the log stream.
 338    *
 339    * @param str The string to write to the log stream.
 340    */
 341   public static void println(String message)
 342   {
 343     if (log_stream != null) // Watch for user not using logging
 344       log_stream.println(message);
 345   }
 346 }