Bring in Adrian's JDBC driver as an interface

src/interfaces/jdbc/JDBC_Test.java

+import java.io.*;
+import java.lang.*;
+import java.sql.*;
+
+class JDBC_Test
+{
+        public JDBC_Test() 
+	{
+	}
+
+	public static void main(String argv[])
+	{
+		String url = new String(argv[0]);
+		Connection db;
+		Statement s;
+		ResultSet rs;
+
+		// Load the driver
+		try
+		{
+			Class.forName("postgresql.Driver");
+		} catch (ClassNotFoundException e) {
+			System.err.println("Exception: " + e.toString());
+		}
+
+		// Lets do a few things -- it doesn't do everything, but
+		// it tests out basic functionality
+		try
+		{
+		System.out.println("Connecting to Database URL = " + url);
+		db = DriverManager.getConnection(url, "adrian", "");
+		System.out.println("Connected...Now creating a statement");
+		s = db.createStatement();
+		System.out.println("Ok...now we will create a table");
+		s.executeUpdate("create table test (a int2, b int2)");
+		System.out.println("Now we will insert some columns");
+		s.executeUpdate("insert into test values (1, 1)");
+		s.executeUpdate("insert into test values (2, 1)");
+		s.executeUpdate("insert into test values (3, 1)");
+		System.out.println("Inserted some data");
+		System.out.println("Now lets try a select");
+		rs = s.executeQuery("select a, b from test");
+		System.out.println("Back from the select...the following are results");
+		int i = 0;
+		while (rs.next())
+		{
+			int a = rs.getInt("a");
+			int b = rs.getInt("b");
+			System.out.println("row " + i + "	" + a + "	" + b);
+			i++;
+		}
+		System.out.println("Ok...dropping the table");
+		s.executeUpdate("drop table test");
+		System.out.println("Now closing the connection");
+		s.close();
+		db.close();
+		} catch (SQLException e) {
+		System.out.println("Exception: " + e.toString());
+		}
+	}
+}

src/interfaces/jdbc/postgresql/CallableStatement.java

+package postgresql;
+
+import java.math.*;
+import java.sql.*;
+
+/**
+ * @version 1.0 15-APR-1997
+ * @author <A HREF="mailto:adrian@hottub.org">Adrian Hall</A>
+ *
+ * CallableStatement is used to execute SQL stored procedures.
+ *
+ * JDBC provides a stored procedure SQL escape that allows stored procedures
+ * to be called in a standard way for all RDBMS's.  This escape syntax has
+ * one form that includes a result parameter and one that does not.  If used,
+ * the result parameter must be generated as an OUT parameter.  The other
+ * parameters may be used for input, output or both.  Parameters are refered
+ * to sequentially, by number.  The first parameter is 1.
+ *
+ * <PRE>
+ *	{?= call <procedure-name>[<arg1>,<arg2>, ...]}
+ *	{call <procedure-name>[<arg1>,<arg2>, ...]}
+ * </PRE>
+ *
+ * IN parameters are set using the set methods inherited from 
+ * PreparedStatement.  The type of all OUT parameters must be registered
+ * prior to executing the stored procedure; their values are retrieved
+ * after execution via the get methods provided here.
+ *
+ * A CallableStatement may return a ResultSet or multiple ResultSets.  Multiple
+ * ResultSets are handled using operations inherited from Statement.
+ *
+ * For maximum portability, a call's ResultSets and update counts should be
+ * processed prior to getting the values of output parameters.
+ *
+ * @see java.sql.Connection#prepareCall
+ * @see java.sql.ResultSet
+ * @see java.sql.CallableStatement
+ */
+public class CallableStatement implements java.sql.CallableStatement 
+{
+	public void registerOutParameter (int paramterIndex, int sqlType) throws SQLException
+	{
+		// XXX-Not Implemented
+	}
+
+	public void registerOutParameter (int parameterIndex, int sqlType, int scale) throws SQLException
+	{
+		// XXX-Not Implemented
+	}
+
+	public boolean wasNull () throws SQLException
+	{
+		// XXX-Not Implemented
+	}
+
+	public String getString (int parameterIndex) throws SQLException
+	{
+		// XXX-Not Implemented
+	}
+
+	public boolean getBoolean (int parameterIndex) throws SQLException
+	{
+		// XXX-Not Implemented
+	}
+
+	public byte getByte (int parameterIndex) throws SQLException
+	{
+		// XXX-Not Implemented
+	}
+
+	public short getShort (int parameterIndex) throws SQLException
+	{
+		// XXX-Not Implemented
+	}
+
+	public int getInt (int parameterIndex) throws SQLException
+	{
+		// XXX-Not Implemented
+	}
+
+	public long getLong (int parameterIndex) throws SQLException
+	{
+		// XXX-Not Implemented
+	}
+
+	public float getFloat (int parameterIndex) throws SQLException
+	{
+		// XXX-Not Implemented
+	}
+
+	public double getDouble (int parameterIndex) throws SQLException
+	{
+		// XXX-Not Implemented
+	}
+
+	public BigDecimal getBigDecimal (int parameterIndex, int scale) throws SQLException
+	{
+		// XXX-Not Implemented
+	}
+
+	public byte[] getBytes (int parameterIndex) throws SQLException
+	{
+		// XXX-Not Implemented
+	}
+
+	public Date getDate (int parameterIndex) throws SQLException
+	{
+		// XXX-Not Implemented
+	}
+
+	public Time getTime (int parameterIndex) throws SQLException
+	{
+		// XXX-Not Implemented
+	}
+
+	public Timestamp getTimestamp (int parameterIndex) throws SQLException
+	{
+		// XXX-Not Implemented
+	}
+
+	public Object getObject (int parameterIndex) throws SQLException
+	{
+		// XXX-Not Implemented
+	}
+
+}

src/interfaces/jdbc/postgresql/Driver.java

+package postgresql;
+
+import java.sql.*;
+import java.util.*;
+import postgresql.*;
+
+/**
+ * @version 1.0 15-APR-1997
+ * @author <A HREF="mailto:adrian@hottub.org">Adrian Hall</A>
+ *
+ * The Java SQL framework allows for multiple database drivers.  Each
+ * driver should supply a class that implements the Driver interface
+ *
+ * The DriverManager will try to load as many drivers as it can find and then
+ * for any given connection request, it will ask each driver in turn to try
+ * to connect to the target URL.
+ *
+ * It is strongly recommended that each Driver class should be small and
+ * standalone so that the Driver class can be loaded and queried without
+ * bringing in vast quantities of supporting code.
+ *
+ * When a Driver class is loaded, it should create an instance of itself and
+ * register it with the DriverManager.  This means that a user can load and
+ * register a driver by doing Class.forName("foo.bah.Driver")
+ *
+ * @see postgresql.Connection
+ * @see java.sql.Driver
+ */
+public class Driver implements java.sql.Driver 
+{
+
+	static 
+	{
+		try
+		{
+			new Driver();
+		} catch (SQLException e) {
+			e.printStackTrace();
+		}
+	}
+
+	/**
+	  * Construct a new driver and register it with DriverManager
+	  *
+	  * @exception SQLException for who knows what!
+	  */
+	public Driver() throws SQLException
+	{
+		java.sql.DriverManager.registerDriver(this);
+	}
+	
+	/**
+	 * Try to make a database connection to the given URL.  The driver
+	 * should return "null" if it realizes it is the wrong kind of
+	 * driver to connect to the given URL.  This will be common, as
+	 * when the JDBC driverManager is asked to connect to a given URL,
+	 * it passes the URL to each loaded driver in turn.
+	 *
+	 * The driver should raise an SQLException if it is the right driver
+	 * to connect to the given URL, but has trouble connecting to the
+	 * database.
+	 *
+	 * The java.util.Properties argument can be used to pass arbitrary
+	 * string tag/value pairs as connection arguments.  Normally, at least
+	 * "user" and "password" properties should be included in the 
+	 * properties.
+	 *
+	 * Our protocol takes the form:
+	 * <PRE>
+	 *	jdbc:postgresql://host:port/database
+	 * </PRE>
+	 *
+	 * @param url the URL of the database to connect to
+	 * @param info a list of arbitrary tag/value pairs as connection
+	 *	arguments
+	 * @return a connection to the URL or null if it isnt us
+	 * @exception SQLException if a database access error occurs
+	 * @see java.sql.Driver#connect
+	 */
+	public java.sql.Connection connect(String url, Properties info) throws SQLException
+	{
+		DriverURL dr = new DriverURL(url);
+		int port;
+
+		if (!(dr.protocol().equals("jdbc")))
+                        return null;
+		if (!(dr.subprotocol().equals("postgresql")))
+                        return null;
+		if (dr.host().equals("unknown"))
+                        return null;
+		port = dr.port();
+		if (port == -1)
+                        port = 5432;    // Default PostgreSQL port
+		return new Connection (dr.host(), port, info, dr.database(), url, this);
+	}
+
+	/**
+	 * Returns true if the driver thinks it can open a connection to the
+	 * given URL.  Typically, drivers will return true if they understand
+	 * the subprotocol specified in the URL and false if they don't.  Our
+	 * protocols start with jdbc:postgresql:
+	 *
+	 * @see java.sql.Driver#acceptsURL
+	 * @param url the URL of the driver
+	 * @return true if this driver accepts the given URL
+         * @exception SQLException if a database-access error occurs
+	 * 	(Dont know why it would *shrug*)
+	 */
+	public boolean acceptsURL(String url) throws SQLException
+	{
+		DriverURL dr = new DriverURL(url);
+
+		if (dr.protocol().equals("jdbc"))
+			if (dr.subprotocol().equals("postgresql"))
+				return true;
+		return false;
+	}
+
+	/**
+	 * The getPropertyInfo method is intended to allow a generic GUI
+	 * tool to discover what properties it should prompt a human for
+	 * in order to get enough information to connect to a database.
+	 * Note that depending on the values the human has supplied so
+	 * far, additional values may become necessary, so it may be necessary
+	 * to iterate through several calls to getPropertyInfo
+	 *
+	 * @param url the Url of the database to connect to
+	 * @param info a proposed list of tag/value pairs that will be sent on
+	 * 	connect open.
+	 * @return An array of DriverPropertyInfo objects describing
+	 * 	possible properties.  This array may be an empty array if
+	 *	no properties are required
+	 * @exception SQLException if a database-access error occurs
+	 * @see java.sql.Driver#getPropertyInfo
+	 */
+	public DriverPropertyInfo[] getPropertyInfo(String url, Properties info) throws SQLException
+	{
+		return null;		// We don't need anything except
+					// the username, which is a default
+	}
+
+	/**
+	 * Gets the drivers major version number
+	 *
+	 * @return the drivers major version number
+	 */
+	public int getMajorVersion()
+	{
+		return 1;
+	}
+	
+	/**
+	 * Get the drivers minor version number
+	 *
+	 * @return the drivers minor version number
+	 */
+	public int getMinorVersion()
+	{
+		return 0;
+	}
+	
+	/**
+	 * Report whether the driver is a genuine JDBC compliant driver.  A
+	 * driver may only report "true" here if it passes the JDBC compliance
+	 * tests, otherwise it is required to return false.  JDBC compliance
+	 * requires full support for the JDBC API and full support for SQL 92
+	 * Entry Level.  
+	 */
+	public boolean jdbcCompliant()
+	{
+		return false;
+	}
+}
+
+/**
+ * The DriverURL class splits a JDBC URL into its subcomponents
+ *
+ *	protocol:subprotocol:/[/host[:port]/][database]
+ */
+class DriverURL
+{
+	private String protocol, subprotocol, host, database;
+	private int port = -1;
+
+	/**
+	 * Constructs a new DriverURL, splitting the specified URL into its
+	 * component parts
+	 */
+	public DriverURL(String url) throws SQLException
+	{
+		int a, b, c;
+		String tmp, hostport, dbportion;
+
+		a = url.indexOf(':');
+		if (a == -1)
+			throw new SQLException("Bad URL Protocol specifier");
+		b = url.indexOf(':', a+1);
+		if (b == -1)
+			throw new SQLException("Bad URL Subprotocol specifier");
+                protocol = new String(url.substring(0, a));
+		subprotocol = new String(url.substring(a+1, b));
+                tmp = new String(url.substring(b+1, url.length()));
+		if (tmp.length() < 2)
+			throw new SQLException("Bad URL Database specifier");
+                if (!tmp.substring(0, 2).equals("//"))
+		{
+			host = new String("unknown");
+			port = -1;
+			database = new String(tmp.substring(1, tmp.length()));
+			return;
+		}
+		dbportion = new String(tmp.substring(2, tmp.length()));
+		c = dbportion.indexOf('/');
+		if (c == -1)
+			throw new SQLException("Bad URL Database specifier");
+		a = dbportion.indexOf(':');
+		if (a == -1)
+		{
+			host = new String(dbportion.substring(0, c));
+			port = -1;
+			database = new String(dbportion.substring(c+1, dbportion.length()));
+		} else {
+			host = new String(dbportion.substring(0, a));
+			port = Integer.valueOf(dbportion.substring(a+1, c)).intValue();
+			database = new String(dbportion.substring(c+1, dbportion.length()));
+		}
+	}
+
+	/**
+	 * Returns the protocol name of the DriverURL
+	 */
+	public String protocol()
+	{
+		return protocol;
+	}
+
+	/**
+	 * Returns the subprotocol name of the DriverURL
+	 */
+	public String subprotocol()
+	{
+		return subprotocol;
+	}
+
+	/**
+	 * Returns the hostname portion of the URL
+	 */
+	public String host()
+	{
+		return host;
+	}
+
+	/**
+	 * Returns the port number portion of the URL
+	 * or -1 if no port was specified
+	 */
+	public int port()
+	{
+		return port;
+	}
+
+	/**
+	 * Returns the database name of the URL
+	 */
+	public String database()
+	{
+		return database;
+	}
+}

src/interfaces/jdbc/postgresql/Field.java

+package postgresql;
+
+import java.lang.*;
+import java.sql.*;
+import java.util.*;
+import postgresql.*;
+
+/**
+ * postgresql.Field is a class used to describe fields in a PostgreSQL ResultSet
+ *
+ * @version 1.0 15-APR-1997
+ * @author <A HREF="mailto:adrian@hottub.org">Adrian Hall</A>
+ */
+public class Field
+{
+	int length;		// Internal Length of this field
+	int oid;		// OID of the type
+	Connection conn;	// Connection Instantation
+	String name;		// Name of this field
+
+	int sql_type = -1;	// The entry in java.sql.Types for this field
+	String type_name = null;// The sql type name
+
+	/**
+	 *	Construct a field based on the information fed to it.
+	 *
+	 * @param conn the connection this field came from
+	 * @param name the name of the field
+	 * @param oid the OID of the field
+	 * @param len the length of the field
+	 */
+	public Field(Connection conn, String name, int oid, int length)
+	{
+		this.conn = conn;
+		this.name = name;
+		this.oid = oid;
+		this.length = length;
+	}
+
+	/**
+	 * the ResultSet and ResultMetaData both need to handle the SQL
+	 * type, which is gained from another query.  Note that we cannot
+	 * use getObject() in this, since getObject uses getSQLType().
+	 *
+	 * @return the entry in Types that refers to this field
+	 * @exception SQLException if a database access error occurs
+	 */
+	public int getSQLType() throws SQLException
+	{
+		if (sql_type == -1)
+		{
+			ResultSet result = (postgresql.ResultSet)conn.ExecSQL("select typname from pg_type where oid = " + oid);
+			if (result.getColumnCount() != 1 || result.getTupleCount() != 1)
+				throw new SQLException("Unexpected return from query for type");
+			result.next();
+			type_name = result.getString(1);
+			if (type_name.equals("int2"))				sql_type = Types.SMALLINT;
+			else if (type_name.equals("int4"))			sql_type = Types.INTEGER;
+			else if (type_name.equals("int8"))			sql_type = Types.BIGINT;
+			else if (type_name.equals("cash"))			sql_type = Types.DECIMAL;
+			else if (type_name.equals("money"))			sql_type = Types.DECIMAL;
+			else if (type_name.equals("float4"))			sql_type = Types.REAL;
+			else if (type_name.equals("float8"))			sql_type = Types.DOUBLE;
+			else if (type_name.equals("bpchar"))			sql_type = Types.CHAR;
+			else if (type_name.equals("varchar"))			sql_type = Types.VARCHAR;
+			else if (type_name.equals("bool"))			sql_type = Types.BIT;
+			else if (type_name.equals("date"))			sql_type = Types.DATE;
+			else if (type_name.equals("time"))			sql_type = Types.TIME;
+			else if (type_name.equals("abstime"))			sql_type = Types.TIMESTAMP;
+			else							sql_type = Types.OTHER;
+		}	
+		return sql_type;
+	}
+
+	/**
+	 * We also need to get the type name as returned by the back end.
+	 * This is held in type_name AFTER a call to getSQLType.  Since
+	 * we get this information within getSQLType (if it isn't already
+	 * done), we can just call getSQLType and throw away the result.
+	 *
+	 * @return the String representation of the type of this field
+	 * @exception SQLException if a database access error occurs
+	 */
+	public String getTypeName() throws SQLException
+	{
+		int sql = getSQLType();
+		return type_name;
+	}
+}

src/interfaces/jdbc/postgresql/PG_Object.java

+package postgresql;
+
+import java.lang.*;
+import java.sql.*;
+import java.util.*;
+import postgresql.*;
+
+/**
+ * postgresql.PG_Object is a class used to describe unknown types 
+ * An unknown type is any type that is unknown by JDBC Standards
+ *
+ * @version 1.0 15-APR-1997
+ * @author <A HREF="mailto:adrian@hottub.org">Adrian Hall</A>
+ */
+public class PG_Object
+{
+	public String	type;
+	public String	value;
+
+	/**
+	 *	Constructor for the PostgreSQL generic object
+	 *
+	 * @param type a string describing the type of the object
+	 * @param value a string representation of the value of the object
+	 */
+	public PG_Object(String type, String value)
+	{
+		this.type = type;
+		this.value = value;
+	}
+}

src/interfaces/jdbc/postgresql/PreparedStatement.java

+package postgresql;
+
+import java.io.*;
+import java.math.*;
+import java.sql.*;
+import java.text.*;
+import java.util.*;
+
+/**
+ * @version 1.0 15-APR-1997
+ * @author <A HREF="mailto:adrian@hottub.org">Adrian Hall</A>
+ *
+ * A SQL Statement is pre-compiled and stored in a PreparedStatement object.
+ * This object can then be used to efficiently execute this statement multiple
+ * times.
+ *
+ * <B>Note:</B> The setXXX methods for setting IN parameter values must
+ * specify types that are compatible with the defined SQL type of the input
+ * parameter.  For instance, if the IN parameter has SQL type Integer, then
+ * setInt should be used.
+ *
+ * If arbitrary parameter type conversions are required, then the setObject 
+ * method should be used with a target SQL type.
+ *
+ * @see ResultSet
+ * @see java.sql.PreparedStatement
+ */
+public class PreparedStatement extends Statement implements java.sql.PreparedStatement 
+{
+	String sql;
+	String[] templateStrings;
+	String[] inStrings;
+	Connection connection;
+
+	/**
+	 * Constructor for the PreparedStatement class.  Split the SQL statement
+	 * into segments - separated by the arguments.  When we rebuild the
+	 * thing with the arguments, we can substitute the args and join the
+	 * whole thing together.
+	 *
+	 * @param conn the instanatiating connection
+	 * @param sql the SQL statement with ? for IN markers
+	 * @exception SQLException if something bad occurs
+	 */
+	public PreparedStatement(Connection connection, String sql) throws SQLException
+	{
+		super(connection);
+
+		Vector v = new Vector();
+		boolean inQuotes = false;
+		int lastParmEnd = 0, i;
+
+		this.sql = sql;
+		this.connection = connection;
+		for (i = 0; i < sql.length(); ++i)
+		{
+			int c = sql.charAt(i);
+
+			if (c == '\'')
+				inQuotes = !inQuotes;
+			if (c == '?' && !inQuotes)
+			{
+				v.addElement(sql.substring (lastParmEnd, i));
+				lastParmEnd = i + 1;
+			}
+		}
+		v.addElement(sql.substring (lastParmEnd, sql.length()));
+
+		templateStrings = new String[v.size()];
+		inStrings = new String[v.size() - 1];
+		clearParameters();
+
+		for (i = 0 ; i < templateStrings.length; ++i)
+			templateStrings[i] = (String)v.elementAt(i);
+	}
+
+	/**
+	 * A Prepared SQL query is executed and its ResultSet is returned
+	 *
+	 * @return a ResultSet that contains the data produced by the
+	 *	query - never null
+	 * @exception SQLException if a database access error occurs
+	 */
+	public java.sql.ResultSet executeQuery() throws SQLException
+	{
+		StringBuffer s = new StringBuffer();
+		int i;
+
+		for (i = 0 ; i < inStrings.length ; ++i)
+		{
+			if (inStrings[i] == null)
+				throw new SQLException("No value specified for parameter " + (i + 1));
+			s.append (templateStrings[i]);
+			s.append (inStrings[i]);
+		}
+		s.append(templateStrings[inStrings.length]);
+		return super.executeQuery(s.toString()); 	// in Statement class
+	}
+
+	/**
+	 * Execute a SQL INSERT, UPDATE or DELETE statement.  In addition,
+	 * SQL statements that return nothing such as SQL DDL statements can
+	 * be executed.
+	 *
+	 * @return either the row count for INSERT, UPDATE or DELETE; or
+	 * 	0 for SQL statements that return nothing.
+	 * @exception SQLException if a database access error occurs
+	 */
+	public int executeUpdate() throws SQLException
+	{
+		StringBuffer s = new StringBuffer();
+		int i;
+
+		for (i = 0 ; i < inStrings.length ; ++i)
+		{
+			if (inStrings[i] == null)
+				throw new SQLException("No value specified for parameter " + (i + 1));
+			s.append (templateStrings[i]);
+			s.append (inStrings[i]);
+		}
+		s.append(templateStrings[inStrings.length]);
+		return super.executeUpdate(s.toString()); 	// in Statement class
+	}	
+
+	/**
+	 * Set a parameter to SQL NULL
+	 *
+	 * <B>Note:</B> You must specify the parameters SQL type (although
+	 * PostgreSQL ignores it)
+	 *
+	 * @param parameterIndex the first parameter is 1, etc...
+	 * @param sqlType the SQL type code defined in java.sql.Types
+	 * @exception SQLException if a database access error occurs
+	 */
+	public void setNull(int parameterIndex, int sqlType) throws SQLException
+	{
+		set(parameterIndex, "null");
+	}
+
+	/**
+	 * Set a parameter to a Java boolean value.  The driver converts this
+	 * to a SQL BIT value when it sends it to the database.
+	 *
+	 * @param parameterIndex the first parameter is 1...
+	 * @param x the parameter value
+	 * @exception SQLException if a database access error occurs
+	 */
+	public void setBoolean(int parameterIndex, boolean x) throws SQLException
+	{
+		set(parameterIndex, x ? "'t'" : "'f'");
+	}
+
+	/**
+	 * Set a parameter to a Java byte value.  The driver converts this to
+	 * a SQL TINYINT value when it sends it to the database.
+	 *
+	 * @param parameterIndex the first parameter is 1...
+	 * @param x the parameter value
+	 * @exception SQLException if a database access error occurs
+	 */
+	public void setByte(int parameterIndex, byte x) throws SQLException
+	{
+		set(parameterIndex, (new Integer(x)).toString());
+	}
+
+	/**
+	 * Set a parameter to a Java short value.  The driver converts this
+	 * to a SQL SMALLINT value when it sends it to the database.
+	 *
+	 * @param parameterIndex the first parameter is 1...
+	 * @param x the parameter value
+	 * @exception SQLException if a database access error occurs
+	 */
+	public void setShort(int parameterIndex, short x) throws SQLException
+	{
+		set(parameterIndex, (new Integer(x)).toString());
+	}
+
+	/**
+	 * Set a parameter to a Java int value.  The driver converts this to
+	 * a SQL INTEGER value when it sends it to the database.
+	 *
+	 * @param parameterIndex the first parameter is 1...
+	 * @param x the parameter value
+	 * @exception SQLException if a database access error occurs
+	 */
+	public void setInt(int parameterIndex, int x) throws SQLException
+	{
+		set(parameterIndex, (new Integer(x)).toString());
+	}
+
+	/**
+	 * Set a parameter to a Java long value.  The driver converts this to
+	 * a SQL BIGINT value when it sends it to the database.
+	 *
+	 * @param parameterIndex the first parameter is 1...
+	 * @param x the parameter value
+	 * @exception SQLException if a database access error occurs
+	 */
+	public void setLong(int parameterIndex, long x) throws SQLException
+	{
+		set(parameterIndex, (new Long(x)).toString());
+	}
+
+	/**
+	 * Set a parameter to a Java float value.  The driver converts this
+	 * to a SQL FLOAT value when it sends it to the database.
+	 *
+	 * @param parameterIndex the first parameter is 1...
+	 * @param x the parameter value
+	 * @exception SQLException if a database access error occurs
+	 */
+	public void setFloat(int parameterIndex, float x) throws SQLException
+	{
+		set(parameterIndex, (new Float(x)).toString());
+	}
+
+	/**
+	 * Set a parameter to a Java double value.  The driver converts this
+	 * to a SQL DOUBLE value when it sends it to the database
+	 *
+	 * @param parameterIndex the first parameter is 1...
+	 * @param x the parameter value
+	 * @exception SQLException if a database access error occurs
+	 */
+	public void setDouble(int parameterIndex, double x) throws SQLException
+	{
+		set(parameterIndex, (new Double(x)).toString());
+	}
+
+	/**
+	 * Set a parameter to a java.lang.BigDecimal value.  The driver
+	 * converts this to a SQL NUMERIC value when it sends it to the
+	 * database.
+	 *
+	 * @param parameterIndex the first parameter is 1...
+	 * @param x the parameter value
+	 * @exception SQLException if a database access error occurs
+	 */
+	public void setBigDecimal(int parameterIndex, BigDecimal x) throws SQLException
+	{
+		set(parameterIndex, x.toString());
+	}
+
+	/**
+	 * Set a parameter to a Java String value.  The driver converts this
+	 * to a SQL VARCHAR or LONGVARCHAR value (depending on the arguments
+	 * size relative to the driver's limits on VARCHARs) when it sends it
+	 * to the database.
+	 *
+	 * @param parameterIndex the first parameter is 1...
+	 * @param x the parameter value
+	 * @exception SQLException if a database access error occurs
+	 */
+	public void setString(int parameterIndex, String x) throws SQLException
+	{
+		StringBuffer b = new StringBuffer();
+		int i;
+
+		b.append('\'');
+		for (i = 0 ; i < x.length() ; ++i)
+		{
+			char c = x.charAt(i);
+			if (c == '\\' || c == '\'')
+				b.append((char)'\\');
+			b.append(c);
+		}
+		b.append('\'');
+		set(parameterIndex, b.toString());
+	}
+
+	/**
+	 * Set a parameter to a Java array of bytes.  The driver converts this
+	 * to a SQL VARBINARY or LONGVARBINARY (depending on the argument's
+	 * size relative to the driver's limits on VARBINARYs) when it sends
+	 * it to the database.
+	 *
+	 * @param parameterIndex the first parameter is 1...
+	 * @param x the parameter value
+	 * @exception SQLException if a database access error occurs
+	 */
+	public void setBytes(int parameterIndex, byte x[]) throws SQLException
+	{
+		throw new SQLException("Binary Data not supported");
+	}
+
+	/**
+	 * Set a parameter to a java.sql.Date value.  The driver converts this
+	 * to a SQL DATE value when it sends it to the database.
+	 *
+	 * @param parameterIndex the first parameter is 1...
+	 * @param x the parameter value
+	 * @exception SQLException if a database access error occurs
+	 */
+	public void setDate(int parameterIndex, java.sql.Date x) throws SQLException
+	{
+		DateFormat df = DateFormat.getDateInstance();
+
+		set(parameterIndex, "'" + df.format(x) + "'");
+	}
+
+	/**
+	 * Set a parameter to a java.sql.Time value.  The driver converts
+	 * this to a SQL TIME value when it sends it to the database.
+	 *
+	 * @param parameterIndex the first parameter is 1...
+	 * @param x the parameter value
+	 * @exception SQLException if a database access error occurs
+	 */
+	public void setTime(int parameterIndex, Time x) throws SQLException
+	{
+		set(parameterIndex, "'" + x.toString() + "'");
+	}
+
+	/**
+	 * Set a parameter to a java.sql.Timestamp value.  The driver converts
+	 * this to a SQL TIMESTAMP value when it sends it to the database.
+	 *
+	 * @param parameterIndex the first parameter is 1...
+	 * @param x the parameter value
+	 * @exception SQLException if a database access error occurs
+	 */
+	public void setTimestamp(int parameterIndex, Timestamp x) throws SQLException
+	{
+		set(parameterIndex, "'" + x.toString() + "'");
+	}
+
+	/**
+	 * When a very large ASCII value is input to a LONGVARCHAR parameter,
+	 * it may be more practical to send it via a java.io.InputStream.
+	 * JDBC will read the data from the stream as needed, until it reaches
+	 * end-of-file.  The JDBC driver will do any necessary conversion from
+	 * ASCII to the database char format.
+	 *
+	 * <B>Note:</B> This stream object can either be a standard Java
+	 * stream object or your own subclass that implements the standard
+	 * interface.
+	 *
+	 * @param parameterIndex the first parameter is 1...
+	 * @param x the parameter value
+	 * @param length the number of bytes in the stream
+	 * @exception SQLException if a database access error occurs
+	 */
+	public void setAsciiStream(int parameterIndex, InputStream x, int length) throws SQLException
+	{
+		setBinaryStream(parameterIndex, x, length);
+	}
+
+	/**
+	 * When a very large Unicode value is input to a LONGVARCHAR parameter,
+	 * it may be more practical to send it via a java.io.InputStream.
+	 * JDBC will read the data from the stream as needed, until it reaches
+	 * end-of-file.  The JDBC driver will do any necessary conversion from
+	 * UNICODE to the database char format.
+	 *
+	 * <B>Note:</B> This stream object can either be a standard Java
+	 * stream object or your own subclass that implements the standard
+	 * interface.
+	 *
+	 * @param parameterIndex the first parameter is 1...
+	 * @param x the parameter value
+	 * @exception SQLException if a database access error occurs
+	 */
+	public void setUnicodeStream(int parameterIndex, InputStream x, int length) throws SQLException
+	{
+		setBinaryStream(parameterIndex, x, length);
+	}
+
+	/**
+	 * When a very large binary value is input to a LONGVARBINARY parameter,
+	 * it may be more practical to send it via a java.io.InputStream.
+	 * JDBC will read the data from the stream as needed, until it reaches
+	 * end-of-file.  
+	 *
+	 * <B>Note:</B> This stream object can either be a standard Java
+	 * stream object or your own subclass that implements the standard
+	 * interface.
+	 *
+	 * @param parameterIndex the first parameter is 1...
+	 * @param x the parameter value
+	 * @exception SQLException if a database access error occurs
+	 */
+	public void setBinaryStream(int parameterIndex, InputStream x, int length) throws SQLException
+	{
+		throw new SQLException("InputStream as parameter not supported");
+	}
+
+	/**
+	 * In general, parameter values remain in force for repeated used of a
+	 * Statement.  Setting a parameter value automatically clears its
+	 * previous value.  However, in coms cases, it is useful to immediately
+	 * release the resources used by the current parameter values; this
+	 * can be done by calling clearParameters
+	 *
+	 * @exception SQLException if a database access error occurs
+	 */
+	public void clearParameters() throws SQLException
+	{
+		int i;
+
+		for (i = 0 ; i < inStrings.length ; i++)
+			inStrings[i] = null;
+	}
+
+	/**
+	 * Set the value of a parameter using an object; use the java.lang
+	 * equivalent objects for integral values.
+	 *
+	 * The given Java object will be converted to the targetSqlType before
+	 * being sent to the database.
+	 *
+	 * note that this method may be used to pass database-specific
+	 * abstract data types.  This is done by using a Driver-specific
+	 * Java type and using a targetSqlType of java.sql.Types.OTHER
+	 *
+	 * @param parameterIndex the first parameter is 1...
+	 * @param x the object containing the input parameter value
+	 * @param targetSqlType The SQL type to be send to the database
+	 * @param scale For java.sql.Types.DECIMAL or java.sql.Types.NUMERIC
+	 *	types this is the number of digits after the decimal.  For 
+	 *	all other types this value will be ignored.
+	 * @exception SQLException if a database access error occurs
+	 */
+	public void setObject(int parameterIndex, Object x, int targetSqlType, int scale) throws SQLException
+	{
+		switch (targetSqlType)
+		{
+			case Types.TINYINT:
+			case Types.SMALLINT:
+			case Types.INTEGER:
+			case Types.BIGINT:
+			case Types.REAL:
+			case Types.FLOAT:
+			case Types.DOUBLE:
+			case Types.DECIMAL:
+			case Types.NUMERIC:
+				if (x instanceof Boolean)
+					set(parameterIndex, ((Boolean)x).booleanValue() ? "1" : "0");
+				else
+					set(parameterIndex, x.toString());
+				break;
+			case Types.CHAR:
+			case Types.VARCHAR:
+			case Types.LONGVARCHAR:
+				setString(parameterIndex, x.toString());
+			case Types.DATE:
+				setDate(parameterIndex, (java.sql.Date)x);
+			case Types.TIME:
+				setTime(parameterIndex, (Time)x);
+			case Types.TIMESTAMP:
+				setTimestamp(parameterIndex, (Timestamp)x);
+			case Types.OTHER:
+				setString(parameterIndex, ((PG_Object)x).value);
+			default:
+				throw new SQLException("Unknown Types value");
+		}
+	}
+
+	public void setObject(int parameterIndex, Object x, int targetSqlType) throws SQLException
+	{
+		setObject(parameterIndex, x, targetSqlType, 0);
+	}
+
+	public void setObject(int parameterIndex, Object x) throws SQLException
+	{
+		if (x instanceof String)
+			setString(parameterIndex, (String)x);
+		else if (x instanceof BigDecimal)
+			setBigDecimal(parameterIndex, (BigDecimal)x);
+		else if (x instanceof Integer)
+			setInt(parameterIndex, ((Integer)x).intValue());
+		else if (x instanceof Long)
+			setLong(parameterIndex, ((Long)x).longValue());
+		else if (x instanceof Float)
+			setFloat(parameterIndex, ((Float)x).floatValue());
+		else if (x instanceof Double)
+			setDouble(parameterIndex, ((Double)x).doubleValue());
+		else if (x instanceof byte[])
+			setBytes(parameterIndex, (byte[])x);
+		else if (x instanceof java.sql.Date)
+			setDate(parameterIndex, (java.sql.Date)x);
+		else if (x instanceof Time)
+			setTime(parameterIndex, (Time)x);
+		else if (x instanceof Timestamp)
+			setTimestamp(parameterIndex, (Timestamp)x);
+		else if (x instanceof Boolean)
+			setBoolean(parameterIndex, ((Boolean)x).booleanValue());
+		else if (x instanceof PG_Object)
+			setString(parameterIndex, ((PG_Object)x).value);
+		else
+			throw new SQLException("Unknown object type");
+	}
+
+	/**
+	 * Some prepared statements return multiple results; the execute method
+	 * handles these complex statements as well as the simpler form of 
+	 * statements handled by executeQuery and executeUpdate
+	 *
+	 * @return true if the next result is a ResultSet; false if it is an
+	 *	update count or there are no more results
+	 * @exception SQLException if a database access error occurs
+	 */
+	public boolean execute() throws SQLException
+	{
+		StringBuffer s = new StringBuffer();
+		int i;
+
+		for (i = 0 ; i < inStrings.length ; ++i)
+		{
+			if (inStrings[i] == null)
+				throw new SQLException("No value specified for parameter " + (i + 1));
+			s.append (templateStrings[i]);
+			s.append (inStrings[i]);
+		}
+		s.append(templateStrings[inStrings.length]);
+		return super.execute(s.toString()); 	// in Statement class
+	}
+
+	// **************************************************************
+	//	END OF PUBLIC INTERFACE	
+	// **************************************************************
+	
+	/**
+	 * There are a lot of setXXX classes which all basically do
+	 * the same thing.  We need a method which actually does the
+	 * set for us.
+	 *
+	 * @param paramIndex the index into the inString
+	 * @param s a string to be stored
+	 * @exception SQLException if something goes wrong
+	 */
+	private void set(int paramIndex, String s) throws SQLException
+	{
+		if (paramIndex < 1 || paramIndex > inStrings.length)
+			throw new SQLException("Parameter index out of range");
+		inStrings[paramIndex - 1] = s;
+	}
+}

src/interfaces/jdbc/postgresql/ResultSetMetaData.java

+package postgresql;
+
+import java.lang.*;
+import java.sql.*;
+import java.util.*;
+import postgresql.*;
+
+/**
+ * @version 1.0 15-APR-1997
+ * @author <A HREF="mailto:adrian@hottub.org">Adrian Hall</A>
+ *
+ * A ResultSetMetaData object can be used to find out about the types and
+ * properties of the columns in a ResultSet
+ *
+ * @see java.sql.ResultSetMetaData
+ */
+public class ResultSetMetaData implements java.sql.ResultSetMetaData 
+{
+	Vector rows;
+	Field[] fields;
+
+	/**
+	 *	Initialise for a result with a tuple set and
+	 *	a field descriptor set
+	 *
+	 * @param rows the Vector of rows returned by the ResultSet
+	 * @param fields the array of field descriptors
+	 */
+	public ResultSetMetaData(Vector rows, Field[] fields)
+	{
+		this.rows = rows;
+		this.fields = fields;
+	}
+	
+	/**
+	 * Whats the number of columns in the ResultSet?
+	 *
+	 * @return the number
+	 * @exception SQLException if a database access error occurs
+	 */
+	public int getColumnCount() throws SQLException
+	{
+		return fields.length;
+	}
+
+	/**
+	 * Is the column automatically numbered (and thus read-only)
+	 * I believe that PostgreSQL does not support this feature.
+	 *
+	 * @param column the first column is 1, the second is 2...
+	 * @return true if so
+	 * @exception SQLException if a database access error occurs
+	 */
+	public boolean isAutoIncrement(int column) throws SQLException
+	{
+		return false;
+	}
+
+	/**
+	 * Does a column's case matter? ASSUMPTION: Any field that is
+	 * not obviously case insensitive is assumed to be case sensitive
+	 *
+	 * @param column the first column is 1, the second is 2...
+	 * @return true if so
+	 * @exception SQLException if a database access error occurs
+	 */
+	public boolean isCaseSensitive(int column) throws SQLException
+	{
+		int sql_type = getField(column).getSQLType();
+
+		switch (sql_type)
+		{
+			case Types.SMALLINT:
+			case Types.INTEGER:
+			case Types.FLOAT:
+			case Types.REAL:
+			case Types.DOUBLE:
+			case Types.DATE:
+			case Types.TIME:
+			case Types.TIMESTAMP:
+				return false;
+			default:
+				return true;
+		}
+	}
+
+	/**
+	 * Can the column be used in a WHERE clause?  Basically for
+	 * this, I split the functions into two types: recognised
+	 * types (which are always useable), and OTHER types (which
+	 * may or may not be useable).  The OTHER types, for now, I
+	 * will assume they are useable.  We should really query the
+	 * catalog to see if they are useable.
+	 *
+	 * @param column the first column is 1, the second is 2...
+	 * @return true if they can be used in a WHERE clause
+	 * @exception SQLException if a database access error occurs
+	 */
+	public boolean isSearchable(int column) throws SQLException
+	{
+		int sql_type = getField(column).getSQLType();
+
+		// This switch is pointless, I know - but it is a set-up
+		// for further expansion.		
+		switch (sql_type)
+		{
+			case Types.OTHER:
+				return true;
+			default:
+				return true;
+		}
+	}
+
+	/**
+	 * Is the column a cash value?  6.1 introduced the cash/money
+	 * type, which haven't been incorporated as of 970414, so I
+	 * just check the type name for both 'cash' and 'money'
+	 *
+	 * @param column the first column is 1, the second is 2...
+	 * @return true if its a cash column
+	 * @exception SQLException if a database access error occurs
+	 */
+	public boolean isCurrency(int column) throws SQLException
+	{
+		String type_name = getField(column).getTypeName();
+
+		if (type_name.equals("cash"))
+			return true;
+		if (type_name.equals("money"))
+			return true;
+		return false;
+	}
+
+	/**
+	 * Can you put a NULL in this column?  I think this is always
+	 * true in 6.1's case.  It would only be false if the field had
+	 * been defined NOT NULL (system catalogs could be queried?)
+	 *
+	 * @param column the first column is 1, the second is 2...
+	 * @return one of the columnNullable values
+	 * @exception SQLException if a database access error occurs
+	 */
+	public int isNullable(int column) throws SQLException
+	{
+		return columnNullable;	// We can always put NULL in
+	}
+
+	/**
+	 * Is the column a signed number? In PostgreSQL, all numbers
+	 * are signed, so this is trivial.  However, strings are not
+	 * signed (duh!)
+	 * 
+	 * @param column the first column is 1, the second is 2...
+	 * @return true if so
+	 * @exception SQLException if a database access error occurs
+	 */
+	public boolean isSigned(int column) throws SQLException
+	{
+		int sql_type = getField(column).getSQLType();
+	
+		switch (sql_type)
+		{
+			case Types.SMALLINT:
+			case Types.INTEGER:
+			case Types.FLOAT:
+			case Types.REAL:
+			case Types.DOUBLE:
+				return true;
+			case Types.DATE:
+			case Types.TIME:
+			case Types.TIMESTAMP:
+				return false;	// I don't know about these?
+			default:
+				return false;
+		}
+	}
+
+	/**
+	 * What is the column's normal maximum width in characters?
+	 *
+	 * @param column the first column is 1, the second is 2, etc.
+	 * @return the maximum width
+	 * @exception SQLException if a database access error occurs
+	 */
+	public int getColumnDisplaySize(int column) throws SQLException
+	{
+		int max = getColumnLabel(column).length();
+		int i;
+
+		for (i = 0 ; i < rows.size(); ++i)
+		{
+			byte[][] x = (byte[][])(rows.elementAt(i));
+			int xl = x[column - 1].length;
+			if (xl > max)
+				max = xl;
+		}
+		return max;
+	}
+
+	/**
+	 * What is the suggested column title for use in printouts and
+	 * displays?  We suggest the ColumnName!
+	 *
+	 * @param column the first column is 1, the second is 2, etc.
+	 * @return the column label
+	 * @exception SQLException if a database access error occurs
+	 */
+	public String getColumnLabel(int column) throws SQLException
+	{
+		return getColumnName(column);
+	}
+
+	/**
+	 * What's a column's name?
+	 *
+	 * @param column the first column is 1, the second is 2, etc.
+	 * @return the column name
+	 * @exception SQLException if a databvase access error occurs
+	 */
+	public String getColumnName(int column) throws SQLException
+	{
+		return getField(column).name;
+	}
+
+	/**
+	 * What is a column's table's schema?  This relies on us knowing
+	 * the table name....which I don't know how to do as yet.  The 
+	 * JDBC specification allows us to return "" if this is not
+	 * applicable.
+	 *
+	 * @param column the first column is 1, the second is 2...
+	 * @return the Schema
+	 * @exception SQLException if a database access error occurs
+	 */
+	public String getSchemaName(int column) throws SQLException
+	{
+		String table_name = getTableName(column);
+
+		// If the table name is invalid, so are we.
+		if (table_name.equals(""))
+			return "";	
+		return "";		// Ok, so I don't know how to
+					// do this as yet.
+	}
+
+	/**
+	 * What is a column's number of decimal digits.
+	 *
+	 * @param column the first column is 1, the second is 2...
+	 * @return the precision
+	 * @exception SQLException if a database access error occurs
+	 */
+	public int getPrecision(int column) throws SQLException
+	{
+		int sql_type = getField(column).getSQLType();
+
+		switch (sql_type)
+		{
+			case Types.SMALLINT:
+				return 5;	
+			case Types.INTEGER:
+				return 10;
+			case Types.REAL:
+				return 8;
+			case Types.FLOAT:
+				return 16;
+			case Types.DOUBLE:
+				return 16;
+			default:
+				throw new SQLException("no precision for non-numeric data types.");
+		}
+	}
+
+	/**
+	 * What is a column's number of digits to the right of the
+	 * decimal point?
+	 *
+	 * @param column the first column is 1, the second is 2...
+	 * @return the scale
+	 * @exception SQLException if a database access error occurs
+	 */
+	public int getScale(int column) throws SQLException
+	{
+		int sql_type = getField(column).getSQLType();
+
+		switch (sql_type)
+		{
+			case Types.SMALLINT:
+				return 0;
+			case Types.INTEGER:
+				return 0;
+			case Types.REAL:
+				return 8;
+			case Types.FLOAT:
+				return 16;
+			case Types.DOUBLE:
+				return 16;
+			default:
+				throw new SQLException("no scale for non-numeric data types");
+		}
+	}
+
+	/**
+	 * Whats a column's table's name?  How do I find this out?  Both
+	 * getSchemaName() and getCatalogName() rely on knowing the table
+	 * Name, so we need this before we can work on them.
+	 *
+	 * @param column the first column is 1, the second is 2...
+	 * @return column name, or "" if not applicable
+	 * @exception SQLException if a database access error occurs
+	 */
+	public String getTableName(int column) throws SQLException
+	{
+		return "";
+	}
+
+	/**
+	 * What's a column's table's catalog name?  As with getSchemaName(),
+	 * we can say that if getTableName() returns n/a, then we can too -
+	 * otherwise, we need to work on it.
+	 * 
+	 * @param column the first column is 1, the second is 2...
+	 * @return catalog name, or "" if not applicable
+	 * @exception SQLException if a database access error occurs
+	 */
+	public String getCatalogName(int column) throws SQLException
+	{
+		String table_name = getTableName(column);
+
+		if (table_name.equals(""))
+			return "";
+		return "";		// As with getSchemaName(), this
+					// is just the start of it.
+	}
+	
+	/**
+	 * What is a column's SQL Type? (java.sql.Type int)
+	 *
+	 * @param column the first column is 1, the second is 2, etc.
+	 * @return the java.sql.Type value
+	 * @exception SQLException if a database access error occurs
+	 * @see postgresql.Field#getSQLType
+	 * @see java.sql.Types
+	 */
+	public int getColumnType(int column) throws SQLException
+	{
+		return getField(column).getSQLType();
+	}
+
+	/**
+	 * Whats is the column's data source specific type name?
+	 *
+	 * @param column the first column is 1, the second is 2, etc.
+	 * @return the type name
+	 * @exception SQLException if a database access error occurs
+	 */
+	public String getColumnTypeName(int column) throws SQLException
+	{
+		return getField(column).getTypeName();
+	}
+
+	/**
+	 * Is the column definitely not writable?  In reality, we would
+	 * have to check the GRANT/REVOKE stuff for this to be effective,
+	 * and I haven't really looked into that yet, so this will get
+	 * re-visited.
+	 *
+	 * @param column the first column is 1, the second is 2, etc.
+	 * @return true if so
+	 * @exception SQLException if a database access error occurs
+	 */
+	public boolean isReadOnly(int column) throws SQLException
+	{
+		return false;
+	}
+
+	/**
+	 * Is it possible for a write on the column to succeed?  Again, we
+	 * would in reality have to check the GRANT/REVOKE stuff, which
+	 * I haven't worked with as yet.  However, if it isn't ReadOnly, then
+	 * it is obviously writable.
+	 *
+	 * @param column the first column is 1, the second is 2, etc.
+	 * @return true if so
+	 * @exception SQLException if a database access error occurs
+	 */
+	public boolean isWritable(int column) throws SQLException
+	{
+		if (isReadOnly(column))
+			return true;
+		else
+			return false;
+	}
+
+	/**
+	 * Will a write on this column definately succeed?  Hmmm...this
+	 * is a bad one, since the two preceding functions have not been
+	 * really defined.  I cannot tell is the short answer.  I thus
+	 * return isWritable() just to give us an idea.
+	 *
+	 * @param column the first column is 1, the second is 2, etc..
+	 * @return true if so
+	 * @exception SQLException if a database access error occurs
+	 */
+	public boolean isDefinitelyWritable(int column) throws SQLException
+	{
+		return isWritable(column);
+	}
+
+	// ********************************************************
+	// 	END OF PUBLIC INTERFACE
+	// ********************************************************
+	
+	/**
+	 * For several routines in this package, we need to convert
+	 * a columnIndex into a Field[] descriptor.  Rather than do
+	 * the same code several times, here it is.
+	 * 
+	 * @param columnIndex the first column is 1, the second is 2...
+	 * @return the Field description
+	 * @exception SQLException if a database access error occurs
+	 */
+	private Field getField(int columnIndex) throws SQLException
+	{
+		if (columnIndex < 1 || columnIndex > fields.length)
+			throw new SQLException("Column index out of range");
+		return fields[columnIndex - 1];
+	}
+}