Source for java.sql.DriverManager

   1: /* DriverManager.java -- Manage JDBC drivers
   2:    Copyright (C) 1999, 2000, 2001, 2003, 2004 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., 51 Franklin Street, Fifth Floor, Boston, MA
  19: 02110-1301 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.StringTokenizer;
  45: import java.util.Vector;
  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: }