java.sql.DriverManager Maven / Gradle / Ivy
Show all versions of dragome-js-jre Show documentation
/*
* %W% %E%
*
* Copyright (c) 2006, Oracle and/or its affiliates. All rights reserved.
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*/
package java.sql;
// Comment below before mustang integration
import java.util.Properties;
/**
* The basic service for managing a set of JDBC drivers.
* NOTE: The {@link DataSource} interface, new in the
* JDBC 2.0 API, provides another way to connect to a data source.
* The use of a DataSource object is the preferred means of
* connecting to a data source.
*
*
As part of its initialization, the DriverManager class will
* attempt to load the driver classes referenced in the "jdbc.drivers"
* system property. This allows a user to customize the JDBC Drivers
* used by their applications. For example in your
* ~/.hotjava/properties file you might specify:
*
* jdbc.drivers=foo.bah.Driver:wombat.sql.Driver:bad.taste.ourDriver
*
* The DriverManager methods getConnection and
* getDrivers have been enhanced to support the Java Standard Edition
* Service Provider mechanism. JDBC 4.0 Drivers must
* include the file META-INF/services/java.sql.Driver. This file contains the name of the JDBC drivers
* implementation of java.sql.Driver. For example, to load the my.sql.Driver class,
* the META-INF/services/java.sql.Driver file would contain the entry:
*
* my.sql.Driver
*
*
* Applications no longer need to explictly load JDBC drivers using Class.forName(). Existing programs
* which currently load JDBC drivers using Class.forName() will continue to work without
* modification.
*
*
When the method getConnection is called,
* the DriverManager will attempt to
* locate a suitable driver from amongst those loaded at
* initialization and those loaded explicitly using the same classloader
* as the current applet or application.
*
*
* Starting with the Java 2 SDK, Standard Edition, version 1.3, a
* logging stream can be set only if the proper
* permission has been granted. Normally this will be done with
* the tool PolicyTool, which can be used to grant permission
* java.sql.SQLPermission "setLog".
* @see Driver
* @see Connection
*/
public class DriverManager
{
public static java.io.PrintWriter getLogWriter()
{
return logWriter;
}
/**
* Sets the logging/tracing PrintWriter object
* that is used by the DriverManager and all drivers.
*
* There is a minor versioning problem created by the introduction
* of the method setLogWriter. The
* method setLogWriter cannot create a PrintStream object
* that will be returned by getLogStream---the Java platform does
* not provide a backward conversion. As a result, a new application
* that uses setLogWriter and also uses a JDBC 1.0 driver that uses
* getLogStream will likely not see debugging information written
* by that driver.
*
* Starting with the Java 2 SDK, Standard Edition, version 1.3 release, this method checks
* to see that there is an SQLPermission object before setting
* the logging stream. If a SecurityManager exists and its
* checkPermission method denies setting the log writer, this
* method throws a java.lang.SecurityException.
*
* @param out the new logging/tracing PrintStream object;
* null to disable logging and tracing
* @throws SecurityException
* if a security manager exists and its
* checkPermission method denies
* setting the log writer
*
* @see SecurityManager#checkPermission
* @see #getLogWriter
* @since 1.2
*/
public static void setLogWriter(java.io.PrintWriter out)
{
}
//---------------------------------------------------------------
/**
* Attempts to establish a connection to the given database URL.
* The DriverManager attempts to select an appropriate driver from
* the set of registered JDBC drivers.
*
* @param url a database url of the form
* jdbc:subprotocol:subname
* @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
* @exception SQLException if a database access error occurs
*/
/**
* Registers the given driver with the DriverManager.
* A newly-loaded driver class should call
* the method registerDriver to make itself
* known to the DriverManager.
*
* @param driver the new JDBC Driver that is to be registered with the
* DriverManager
* @exception SQLException if a database access error occurs
*/
public static synchronized void registerDriver(java.sql.Driver driver) throws SQLException
{
}
/**
* Drops a driver from the DriverManager's list.
* Applets can only deregister drivers from their own classloaders.
*
* @param driver the JDBC Driver to drop
* @exception SQLException if a database access error occurs
*/
public static synchronized void deregisterDriver(Driver driver) throws SQLException
{
}
/**
* Sets the maximum time in seconds that a driver will wait
* while attempting to connect to a database.
*
* @param seconds the login time limit in seconds; zero means there is no limit
* @see #getLoginTimeout
*/
public static void setLoginTimeout(int seconds)
{
loginTimeout= seconds;
}
/**
* Gets the maximum time in seconds that a driver can wait
* when attempting to log in to a database.
*
* @return the driver login time limit in seconds
* @see #setLoginTimeout
*/
public static int getLoginTimeout()
{
return (loginTimeout);
}
/**
* Retrieves the logging/tracing PrintStream that is used by the DriverManager
* and all drivers.
*
* @return the logging/tracing PrintStream; if disabled, is null
* @deprecated
* @see #setLogStream
*/
public static java.io.PrintStream getLogStream()
{
return logStream;
}
// Class initialization.
static void initialize()
{
}
/* Prevent the DriverManager class from being instantiated. */
private DriverManager()
{
}
/* write copy of the drivers vector */
private static java.util.Vector writeDrivers= new java.util.Vector();
/* write copy of the drivers vector */
private static java.util.Vector readDrivers= new java.util.Vector();
private static int loginTimeout= 0;
private static java.io.PrintWriter logWriter= null;
private static java.io.PrintStream logStream= null;
private static boolean initialized= false;
private static Object logSync= new Object();
/* Returns the caller's class loader, or null if none */
private static native ClassLoader getCallerClassLoader();
public static Connection getConnection(String string)
{
Class className;
try
{
className= Class.forName("org.sqlite.JDBC");
}
catch (ClassNotFoundException e)
{
try
{
className= Class.forName("net.ar.dragome.jdbc.DragomeJdbcDriver");
}
catch (Exception e1)
{
throw new RuntimeException(e1);
}
}
try
{
Driver newInstance= (Driver) className.newInstance();
return newInstance.connect(string, new Properties());
}
catch (Exception e)
{
throw new RuntimeException(e);
}
}
}