Added DataSource code and tests submitted by Aaron Mulder

Author: Dave Cramer

src/interfaces/jdbc/org/postgresql/jdbc2/optional/BaseDataSource.java

@@ -0,0 +1,224 @@
+package org.postgresql.jdbc2.optional;
+
+import javax.naming.*;
+import java.io.PrintWriter;
+import java.sql.*;
+
+/**
+ * Base class for data sources and related classes.
+ *
+ * @author Aaron Mulder (ammulder@chariotsolutions.com)
+ * @version $Revision: 1.1 $
+ */
+public abstract class BaseDataSource implements Referenceable {
+    // Load the normal driver, since we'll use it to actually connect to the
+    // database.  That way we don't have to maintain the connecting code in
+    // multiple places.
+    static {
+        try {
+            Class.forName("org.postgresql.Driver");
+        } catch (ClassNotFoundException e) {
+            System.err.println("PostgreSQL DataSource unable to load PostgreSQL JDBC Driver");
+        }
+    }
+
+    // Needed to implement the DataSource/ConnectionPoolDataSource interfaces
+    private transient PrintWriter logger;
+    // Don't track loginTimeout, since we'd just ignore it anyway
+
+    // Standard properties, defined in the JDBC 2.0 Optional Package spec
+    private String serverName = "localhost";
+    private String databaseName;
+    private String user;
+    private String password;
+    private int portNumber;
+
+    /**
+     * Gets a connection to the PostgreSQL database.  The database is identified by the
+     * DataSource properties serverName, databaseName, and portNumber.  The user to
+     * connect as is identified by the DataSource properties user and password.
+     *
+     * @return A valid database connection.
+     * @throws SQLException
+     *         Occurs when the database connection cannot be established.
+     */
+    public Connection getConnection() throws SQLException {
+        return getConnection(user, password);
+    }
+
+    /**
+     * Gets a connection to the PostgreSQL database.  The database is identified by the
+     * DataAource properties serverName, databaseName, and portNumber.  The user to
+     * connect as is identified by the arguments user and password, which override
+     * the DataSource properties by the same name.
+     *
+     * @return A valid database connection.
+     * @throws SQLException
+     *         Occurs when the database connection cannot be established.
+     */
+    public Connection getConnection(String user, String password) throws SQLException {
+        try {
+            Connection con = DriverManager.getConnection(getUrl(), user, password);
+            if (logger != null) {
+                logger.println("Created a non-pooled connection for " + user + " at " + getUrl());
+            }
+            return con;
+        } catch (SQLException e) {
+            if (logger != null) {
+                logger.println("Failed to create a non-pooled connection for " + user + " at " + getUrl() + ": " + e);
+            }
+            throw e;
+        }
+    }
+
+    /**
+     * This DataSource does not support a configurable login timeout.
+     * @return 0
+     */
+    public int getLoginTimeout() throws SQLException {
+        return 0;
+    }
+
+    /**
+     * This DataSource does not support a configurable login timeout.  Any value
+     * provided here will be ignored.
+     */
+    public void setLoginTimeout(int i) throws SQLException {
+    }
+
+    /**
+     * Gets the log writer used to log connections opened.
+     */
+    public PrintWriter getLogWriter() throws SQLException {
+        return logger;
+    }
+
+    /**
+     * The DataSource will note every connection opened to the provided log writer.
+     */
+    public void setLogWriter(PrintWriter printWriter) throws SQLException {
+        logger = printWriter;
+    }
+
+    /**
+     * Gets the name of the host the PostgreSQL database is running on.
+     */
+    public String getServerName() {
+        return serverName;
+    }
+
+    /**
+     * Sets the name of the host the PostgreSQL database is running on.  If this
+     * is changed, it will only affect future calls to getConnection.  The default
+     * value is <tt>localhost</tt>.
+     */
+    public void setServerName(String serverName) {
+        if(serverName == null || serverName.equals("")) {
+            this.serverName = "localhost";
+        } else {
+            this.serverName = serverName;
+        }
+    }
+
+    /**
+     * Gets the name of the PostgreSQL database, running on the server identified
+     * by the serverName property.
+     */
+    public String getDatabaseName() {
+        return databaseName;
+    }
+
+    /**
+     * Sets the name of the PostgreSQL database, running on the server identified
+     * by the serverName property.  If this is changed, it will only affect
+     * future calls to getConnection.
+     */
+    public void setDatabaseName(String databaseName) {
+        this.databaseName = databaseName;
+    }
+
+    /**
+     * Gets a description of this DataSource-ish thing.  Must be customized by
+     * subclasses.
+     */
+    public abstract String getDescription();
+
+    /**
+     * Gets the user to connect as by default.  If this is not specified, you must
+     * use the getConnection method which takes a user and password as parameters.
+     */
+    public String getUser() {
+        return user;
+    }
+
+    /**
+     * Sets the user to connect as by default.  If this is not specified, you must
+     * use the getConnection method which takes a user and password as parameters.
+     * If this is changed, it will only affect future calls to getConnection.
+     */
+    public void setUser(String user) {
+        this.user = user;
+    }
+
+    /**
+     * Gets the password to connect with by default.  If this is not specified but a
+     * password is needed to log in, you must use the getConnection method which takes
+     * a user and password as parameters.
+     */
+    public String getPassword() {
+        return password;
+    }
+
+    /**
+     * Sets the password to connect with by default.  If this is not specified but a
+     * password is needed to log in, you must use the getConnection method which takes
+     * a user and password as parameters.  If this is changed, it will only affect
+     * future calls to getConnection.
+     */
+    public void setPassword(String password) {
+        this.password = password;
+    }
+
+    /**
+     * Gets the port which the PostgreSQL server is listening on for TCP/IP
+     * connections.
+     *
+     * @return The port, or 0 if the default port will be used.
+     */
+    public int getPortNumber() {
+        return portNumber;
+    }
+
+    /**
+     * Gets the port which the PostgreSQL server is listening on for TCP/IP
+     * connections.  Be sure the -i flag is passed to postmaster when PostgreSQL
+     * is started.  If this is not set, or set to 0, the default port will be used.
+     */
+    public void setPortNumber(int portNumber) {
+        this.portNumber = portNumber;
+    }
+
+    /**
+     * Generates a DriverManager URL from the other properties supplied.
+     */
+    private String getUrl() {
+        return "jdbc:postgresql://"+serverName+(portNumber == 0 ? "" : ":"+portNumber)+"/"+databaseName;
+    }
+
+    public Reference getReference() throws NamingException {
+        Reference ref = new Reference(getClass().getName(), PGObjectFactory.class.getName(), null);
+        ref.add(new StringRefAddr("serverName", serverName));
+        if (portNumber != 0) {
+            ref.add(new StringRefAddr("portNumber", Integer.toString(portNumber)));
+        }
+        ref.add(new StringRefAddr("databaseName", databaseName));
+        if (user != null) {
+            ref.add(new StringRefAddr("user", user));
+        }
+        if (password != null) {
+            ref.add(new StringRefAddr("password", password));
+        }
+        return ref;
+    }
+
+}

src/interfaces/jdbc/org/postgresql/jdbc2/optional/ConnectionPool.java

@@ -0,0 +1,76 @@
+package org.postgresql.jdbc2.optional;
+
+import javax.sql.ConnectionPoolDataSource;
+import javax.sql.PooledConnection;
+import java.sql.SQLException;
+import java.io.Serializable;
+
+/**
+ * PostgreSQL implementation of ConnectionPoolDataSource.  The app server or
+ * middleware vendor should provide a DataSource implementation that takes advantage
+ * of this ConnectionPoolDataSource.  If not, you can use the PostgreSQL implementation
+ * known as PoolingDataSource, but that should only be used if your server or middleware
+ * vendor does not provide their own.  Why? The server may want to reuse the same
+ * Connection across all EJBs requesting a Connection within the same Transaction, or
+ * provide other similar advanced features.
+ *
+ * <p>In any case, in order to use this ConnectionPoolDataSource, you must set the property
+ * databaseName.  The settings for serverName, portNumber, user, and password are
+ * optional.  Note: these properties are declared in the superclass.</p>
+ *
+ * <p>This implementation supports JDK 1.3 and higher.</p>
+ *
+ * @author Aaron Mulder (ammulder@chariotsolutions.com)
+ * @version $Revision: 1.1 $
+ */
+public class ConnectionPool extends BaseDataSource implements Serializable, ConnectionPoolDataSource {
+    private boolean defaultAutoCommit = false;
+
+    /**
+     * Gets a description of this DataSource.
+     */
+    public String getDescription() {
+        return "ConnectionPoolDataSource from "+org.postgresql.Driver.getVersion();
+    }
+
+    /**
+     * Gets a connection which may be pooled by the app server or middleware
+     * implementation of DataSource.
+     *
+     * @throws java.sql.SQLException
+     *         Occurs when the physical database connection cannot be established.
+     */
+    public PooledConnection getPooledConnection() throws SQLException {
+        return new PooledConnectionImpl(getConnection(), defaultAutoCommit);
+    }
+
+    /**
+     * Gets a connection which may be pooled by the app server or middleware
+     * implementation of DataSource.
+     *
+     * @throws java.sql.SQLException
+     *         Occurs when the physical database connection cannot be established.
+     */
+    public PooledConnection getPooledConnection(String user, String password) throws SQLException {
+        return new PooledConnectionImpl(getConnection(user, password), defaultAutoCommit);
+    }
+
+    /**
+     * Gets whether connections supplied by this pool will have autoCommit
+     * turned on by default.  The default value is <tt>false</tt>, so that
+     * autoCommit will be turned off by default.
+     */
+    public boolean isDefaultAutoCommit() {
+        return defaultAutoCommit;
+    }
+
+    /**
+     * Sets whether connections supplied by this pool will have autoCommit
+     * turned on by default.  The default value is <tt>false</tt>, so that
+     * autoCommit will be turned off by default.
+     */
+    public void setDefaultAutoCommit(boolean defaultAutoCommit) {
+        this.defaultAutoCommit = defaultAutoCommit;
+    }
+
+}

src/interfaces/jdbc/org/postgresql/jdbc2/optional/PGObjectFactory.java

@@ -0,0 +1,89 @@
+package org.postgresql.jdbc2.optional;
+
+import javax.naming.spi.ObjectFactory;
+import javax.naming.*;
+import java.util.Hashtable;
+
+/**
+ * Returns a DataSource-ish thing based on a JNDI reference.  In the case of a
+ * SimpleDataSource or ConnectionPool, a new instance is created each time, as
+ * there is no connection state to maintain. In the case of a PoolingDataSource,
+ * the same DataSource will be returned for every invocation within the same
+ * VM/ClassLoader, so that the state of the connections in the pool will be
+ * consistent.
+ *
+ * @author Aaron Mulder (ammulder@chariotsolutions.com)
+ * @version $Revision: 1.1 $
+ */
+public class PGObjectFactory implements ObjectFactory {
+    /**
+     * Dereferences a PostgreSQL DataSource.  Other types of references are
+     * ignored.
+     */
+    public Object getObjectInstance(Object obj, Name name, Context nameCtx,
+                                    Hashtable environment) throws Exception {
+        Reference ref = (Reference)obj;
+        if(ref.getClassName().equals(SimpleDataSource.class.getName())) {
+            return loadSimpleDataSource(ref);
+        } else if (ref.getClassName().equals(ConnectionPool.class.getName())) {
+            return loadConnectionPool(ref);
+        } else if (ref.getClassName().equals(PoolingDataSource.class.getName())) {
+            return loadPoolingDataSource(ref);
+        } else {
+            return null;
+        }
+    }
+
+    private Object loadPoolingDataSource(Reference ref) {
+        // If DataSource exists, return it
+        String name = getProperty(ref, "dataSourceName");
+        PoolingDataSource pds = PoolingDataSource.getDataSource(name);
+        if(pds != null) {
+            return pds;
+        }
+        // Otherwise, create a new one
+        pds = new PoolingDataSource();
+        pds.setDataSourceName(name);
+        loadBaseDataSource(pds, ref);
+        String min = getProperty(ref, "initialConnections");
+        if (min != null) {
+            pds.setInitialConnections(Integer.parseInt(min));
+        }
+        String max = getProperty(ref, "maxConnections");
+        if (max != null) {
+            pds.setMaxConnections(Integer.parseInt(max));
+        }
+        return pds;
+    }
+
+    private Object loadSimpleDataSource(Reference ref) {
+        SimpleDataSource ds = new SimpleDataSource();
+        return loadBaseDataSource(ds, ref);
+    }
+
+    private Object loadConnectionPool(Reference ref) {
+        ConnectionPool cp = new ConnectionPool();
+        return loadBaseDataSource(cp, ref);
+    }
+
+    private Object loadBaseDataSource(BaseDataSource ds, Reference ref) {
+        ds.setDatabaseName(getProperty(ref, "databaseName"));
+        ds.setPassword(getProperty(ref, "password"));
+        String port = getProperty(ref, "portNumber");
+        if(port != null) {
+            ds.setPortNumber(Integer.parseInt(port));
+        }
+        ds.setServerName(getProperty(ref, "serverName"));
+        ds.setUser(getProperty(ref, "user"));
+        return ds;
+    }
+
+    private String getProperty(Reference ref, String s) {
+        RefAddr addr = ref.get(s);
+        if(addr == null) {
+            return null;
+        }
+        return (String)addr.getContent();
+    }
+
+}