Major update part I involving delayed patches, reworked Makefile, and how

the versioning works. There's also a new utils directory used by Makefile

Major update part I involving delayed patches, reworked Makefile, and how
the versioning works. There's also a new utils directory used by Makefile
f41dcbe4 · Peter Mount · f20d2a87 · f41dcbe4 · f41dcbe4 · f41dcbe4
Commit f41dcbe4 authored Oct 12, 2000 by Peter Mount
16 changed files
--- a/src/interfaces/jdbc/CHANGELOG
+++ b/src/interfaces/jdbc/CHANGELOG
+Tue Oct 10 13:12:00 BST 2000 peter@retep.org.uk
+	- DatabaseMetaData.supportsAlterTableWithDropColumn() as psql doesn't
+	  support dropping of individual columns
+	- Merged in some last patches. Only 1 left, which may not be compatible
+	  with jdbc1
+	- Merged in my old retepsql project. Makefile now includes it.
+Mon Oct 02 12:30:00 BST 2000 peter@retep.org.uk
+	- Merged in byte[] array allocation changes submitted by Gunnar R|nning
+	  <gunnar@candleweb.no>
+Mon Sep 25 14:22:00 BST 2000 peter@retep.org.uk
+	- Removed the DriverClass kludge. Now the org.postgresql.Driver class
+	  is compiled from a template file, and now has both the connection
+	  class (ie jdbc1/jdbc2) and the current version's from Makefile.global
+	- 
 Thu Jul 20 16:30:00 BST 2000 petermount@it.maidstone.gov.uk
 	- Fixed DatabaseMetaData.getTableTypes()

--- a/src/interfaces/jdbc/Makefile
+++ b/src/interfaces/jdbc/Makefile
@@ -4,10 +4,15 @@
 #    Makefile for Java JDBC interface
 #
 # IDENTIFICATION
-#    $Id: Makefile,v 1.24 2000/09/12 04:58:46 momjian Exp $
+#    $Id: Makefile,v 1.25 2000/10/12 08:55:23 peter Exp $
 #
 #-------------------------------------------------------------------------
+subdir		= src/interfaces
+top_builddir	= ../../..
+include		$(top_builddir)/src/Makefile.global
+CP		= cp
 FIND		= find
 IDL2JAVA	= idltojava -fno-cpp -fno-tie
 JAR		= jar
@@ -17,6 +22,9 @@ JAVADOC		= javadoc
 RM		= rm -f
 TOUCH		= touch
+BUILDDRIVER	= sh utils/buildDriver
+CHANGELOG	= perl utils/changelog.pl
 # This defines how to compile a java class
 .java.class:
 	$(JAVAC) $<
@@ -28,9 +36,18 @@ TOUCH		= touch
 # postgresql to org/postgresql
 PGBASE		= org/postgresql
+# New for 7.1: The jar filename
+JARFILE		= postgresql.jar
+# Yet another attempt to check the version. In theory, any JVM that fails
+# this is breaking the versioning specifications released by Javasoft.
+#
+all:	utils/CheckVersion.class
+	@$(MAKE) `$(JAVA) utils.CheckVersion`
 # For 6.5.3 and 7.0+, we need to select the correct JDBC API, so prompt
 # for the version.
-all:	
+huho:	
 	@echo ------------------------------------------------------------
 	@echo Due to problems with some JVMs that dont return a meaningful
 	@echo version number, we have had to make the choice of what jdbc
@@ -38,15 +55,20 @@ all:
 	@echo
 	@echo If you are using JDK1.1.x, you will need the JDBC1.2 driver.
 	@echo To compile, type:
-	@echo "  make jdbc1 jar"
+	@echo "  make jdbc1"
 	@echo
 	@echo "If you are using JDK1.2 (aka Java2) you need the JDBC2."
 	@echo To compile, type:
-	@echo "  make jdbc2 jar"
+	@echo "  make jdbc2"
+	@echo
+	@echo "If you are using the Java2 Enterprise Edition, you can use"
+	@echo "either the standard driver above, or compile the standard"
+	@echo "extensions version of the driver. Type:"
+	@echo "  make enterprise"
 	@echo
 	@echo Once you have done this, a postgresql.jar file will be
 	@echo produced. This file will only work with that particular
-	@echo JVM.
+	@echo version of virtual machine.
 	@echo
 	@echo ------------------------------------------------------------
@@ -76,6 +98,10 @@ msg:
 	@echo
 	@echo "To make the tests, type:"
 	@echo "  make tests"
+	@echo
+	@echo "To build the GUI Shell, type:"
+	@echo "  make retepsql"
+	@echo
 	@echo ------------------------------------------------------------
 	@echo
@@ -93,7 +119,6 @@ doc:
 # the jar file.
 OBJ_COMMON=	$(PGBASE)/Connection.class \
 		$(PGBASE)/Driver.class \
-		$(PGBASE)/DriverClass.class \
 		$(PGBASE)/Field.class \
 		$(PGBASE)/PG_Stream.class \
 		$(PGBASE)/ResultSet.class \
@@ -136,53 +161,79 @@ OBJ_JDBC2=	$(PGBASE)/jdbc2/ResultSet.class \
 		$(PGBASE)/jdbc2/Statement.class \
 		$(PGBASE)/largeobject/PGblob.class
+# These files are unique to the JDBC2 Enterprise driver
+OBJ_ENTER=	$(OBJ_JDBC2) \
+		$(PGBASE)/PostgresqlDataSource.class \
+		$(PGBASE)/xa/ClientConnection.class \
+		$(PGBASE)/xa/TwoPhaseConnection.class \
+		$(PGBASE)/xa/TxConnection.class \
+		$(PGBASE)/xa/XAConnectionImpl.class \
+		$(PGBASE)/xa/XADataSourceImpl.class
 # This rule builds the JDBC1 compliant driver
 jdbc1:
-	(echo "package org.postgresql;" ;\
+	$(BUILDDRIVER) $(VERSION) org.postgresql.jdbc1.Connection JDBC1.1 $(PGBASE)/Driver.java
-	 echo "public class DriverClass {" ;\
-	 echo "public static String connectClass=\"org.postgresql.jdbc1.Connection\";" ;\
-	 echo "}" \
-	) >$(PGBASE)/DriverClass.java
 	-$(RM) postgresql.jar
 	@$(MAKE) jdbc1real
 # This rule does the real work for JDBC1.2, however do not call it directly.
 # This is because the JDBC driver relies on the org.postgresql.DriverClass
 # class to determine the driver version.
-jdbc1real: $(PGBASE)/DriverClass.class \
+jdbc1real: $(OBJ_COMMON) $(OBJ_JDBC1) $(JARFILE) msg
-	$(OBJ_COMMON) $(OBJ_JDBC1) postgresql.jar msg
 # This rule builds the JDBC2 compliant driver
 jdbc2:
-	(echo "package org.postgresql;" ;\
+	@$(MAKE) jdbc2internal msg
-	 echo "public class DriverClass {" ;\
-	 echo "public static String connectClass=\"org.postgresql.jdbc2.Connection\";" ;\
+# This allows us to build the jdbc2 driver without displaying the msg
-	 echo "}" \
+# refer to the retepsql rule to see why.
-	) >$(PGBASE)/DriverClass.java
+jdbc2internal:
+	$(BUILDDRIVER) $(VERSION) org.postgresql.jdbc2.Connection Java2 $(PGBASE)/Driver.java
 	-$(RM) postgresql.jar
 	@$(MAKE) jdbc2real
 # This rule does the real work for JDBC2, however do not call it directly.
 # This is because the JDBC driver relies on the org.postgresql.DriverClass
 # class to determine the driver version.
-jdbc2real: $(PGBASE)/DriverClass.class \
+jdbc2real: $(OBJ_COMMON) $(OBJ_JDBC2) $(JARFILE)
-	$(OBJ_COMMON) $(OBJ_JDBC2) postgresql.jar msg
+# This rule builds the enterprise edition of the driver
+enterprise:
+	$(BUILDDRIVER) $(VERSION) org.postgresql.jdbc2.Connection Enterprise $(PGBASE)/Driver.java
+	-$(RM) postgresql.jar
+	@$(MAKE) enterprisereal
-# If you have problems with this rule, replace the $( ) with ` ` as some
+# This rule does the real work for JDBC2 Enterprise Edition, however do not
-# shells (mainly sh under Solaris) doesn't recognise $( )
+# call it directly. This is because the JDBC driver relies on the
+# org.postgresql.DriverClass class to determine the driver version.
+enterprisereal: $(OBJ_COMMON) $(OBJ_ENTER) $(JARFILE)
+# We use the old `cmd` notation here as some older shells (mainly sh under
+# Solaris) don't recognise the newer $(cmd) syntax.
 #
-postgresql.jar: $(OBJ) $(OBJ_COMMON)
+$(JARFILE): $(OBJ) $(OBJ_COMMON)
 	$(JAR) -c0f $@ `$(FIND) $(PGBASE) -name "*.class" -print` \
 		$(wildcard $(PGBASE)/*.properties)
 # This rule removes any temporary and compiled files from the source tree.
+#
 clean:
 	$(FIND) . -name "*~" -exec $(RM) {} \;
 	$(FIND) . -name "*.class" -exec $(RM) {} \;
-	$(FIND) . -name "*.html" -exec $(RM) {} \;
 	-$(RM) -rf stock example/corba/stock.built
-	-$(RM) postgresql.jar org/postgresql/DriverClass.java
+	-$(RM) postgresql.jar org/postgresql/Driver.java
 	-$(RM) -rf Package-postgresql *output
+	-$(RM) retepsql.jar manifest
+# New for 7.1
+install:	$(JARFILE)
+	$(CP) $(JARFILE) $(libdir)
+# This converts CHANGELOG into an html format - used by peter@retep.org.uk
+# to produce an online version
+changelog: changelog.html
+changelog.html: CHANGELOG
+	$(CHANGELOG) $< >$@
 #######################################################################
 # This helps make workout what classes are from what source files
@@ -311,3 +362,60 @@ example/corba/stock.built: example/corba/stock.idl
 # tip: we cant use $(wildcard stock/*.java) in the above rule as a race
 #      condition occurs, where javac is passed no arguments
 #######################################################################
+#
+# JPGSql	This isn't really an example, but an entire frontend
+#		for PostgreSQL via Java & JDBC.
+#
+# Requirements:	Java2 platform (JDK1.2.x or 1.3)
+#
+retepsql:	jdbc2internal postgresql.jar
+	-$(RM) retepsql.jar
+	@$(MAKE) retepsql.jar
+	@echo
+	@echo "The retepsql application has now been built. To run, simply"
+	@echo "type:"
+	@echo
+	@echo "  java -jar retepsql.jar"
+	@echo
+	@echo "Note: Some operating systems recognise .jar as an executable,"
+	@echo "      so on those (and Windows is one of them), you can simply"
+	@echo "      double click the jar file to start it."
+# All my classes have this prefix
+RETEP=		uk/org/retep
+# These classes form part of my personal swing library. I have placed these
+# into the public domain, so there are no license issues... enjoy...
+RETEPUTILS=	$(RETEP)/swing/SwingApplication.class \
+		$(RETEP)/swing/SwingApplication.class \
+# This is my postgresql frontend. As it's never been released before, I've
+# decided not only to publish it under the same licence as the JDBC driver,
+# but also to put it along side the driver. To me it makes sense as it's the
+# best example I have on showing how to use the driver ;-)
+RETEPSQL=	$(RETEP)/sql/DBConnection.class \
+		$(RETEP)/sql/RetepSQL.class \
+# Some ancilary files which are included in the jar file
+RETEPSQLAUX=	$(RETEP)/icons/ \
+# The big rule, this builds the jpgsql.jar file which contains the entire
+# application. DONT call this rule directly, but use the retepsql one, as
+# it ensures that jdbc is also compiled first.
+#
+# Note: We include the postgresql.jar contents in this as well. Also the
+# manifest entry MUST be immediately after $@ (note the -m option to jar).
+#
+retepsql.jar:	$(RETEPUTILS) \
+		$(RETEPSQL)
+	(echo "Manifest-Version: 1.0"; \
+	 echo "Created-By: 1.2 (Sun Microsystems Inc.)"; \
+	 echo "Main-Class: uk.org.retep.sql.RetepSQL"; \
+	) >manifest
+	$(JAR) -c0fm $@ manifest \
+		`$(FIND) $(PGBASE) -name "*.class" -print` \
+		$(wildcard $(PGBASE)/*.properties) \
+		`$(FIND) $(RETEP) -name "*.class" -print` \
+		$(RETEPSQLAUX)
+#######################################################################
--- a/src/interfaces/jdbc/example/psql.java
+++ b/src/interfaces/jdbc/example/psql.java
@@ -15,6 +15,7 @@ public class psql
  Connection	   db;		// The connection to the database
  Statement	   st;		// Our statement to run queries with
  DatabaseMetaData dbmd;	// This defines the structure of the database
+  boolean done = false;         // Added by CWJ to permit \q command
  public psql(String args[]) throws ClassNotFoundException, FileNotFoundException, IOException, SQLException
  {
@@ -44,11 +45,11 @@ public class psql
    input.eolIsSignificant(false);	// treat eol's as spaces
    input.wordChars(32,126);
    input.whitespaceChars(59,59);
-    input.quoteChar(39);
+    // input.quoteChar(39); *** CWJ: messes up literals in query string ***
    // Now the main loop.
    int tt=0,lineno=1;
-    while(tt!=StreamTokenizer.TT_EOF) {
+    while(tt!=StreamTokenizer.TT_EOF && ! done) { // done added by CWJ to permit \q command
      System.out.print("["+lineno+"] ");
      System.out.flush();
@@ -164,7 +165,9 @@ public class psql
 	//
 	displayResult(dbmd.getTables(null,null,"%",types));
      }
-    } else
+    } else if(line.equals("\\q")) // Added by CWJ to permit \q command
+        done = true;
+    else
      throw new SQLException("Unsupported \\ command: "+line);
  }

--- a/src/interfaces/jdbc/example/threadsafe.java
+++ b/src/interfaces/jdbc/example/threadsafe.java
@@ -145,7 +145,7 @@ public class threadsafe
 	// manner. (DateStyles are PostgreSQL's way of handling different methods
 	// of representing dates in the Date data type.)
 	PreparedStatement ps = db.prepareStatement("insert into basic1 values (?,?)");
-	for(int i=2;i<200;i++) {
+	for(int i=2;i<2000;i++) {
 	  ps.setInt(1,4);		// "column a" = 5
 	  ps.setInt(2,i);		// "column b" = i
 	  ps.executeUpdate();	// executeUpdate because insert returns no data
@@ -212,7 +212,7 @@ public class threadsafe
 	// manner. (DateStyles are PostgreSQL's way of handling different methods
 	// of representing dates in the Date data type.)
 	PreparedStatement ps = db.prepareStatement("insert into basic2 values (?,?)");
-	for(int i=2;i<200;i++) {
+	for(int i=2;i<2000;i++) {
 	  ps.setInt(1,4);		// "column a" = 5
 	  ps.setInt(2,i);		// "column b" = i
 	  ps.executeUpdate();	// executeUpdate because insert returns no data

--- a/src/interfaces/jdbc/org/postgresql/Connection.java
+++ b/src/interfaces/jdbc/org/postgresql/Connection.java
@@ -10,7 +10,7 @@ import org.postgresql.largeobject.*;
 import org.postgresql.util.*;
 /**
- * $Id: Connection.java,v 1.8 2000/10/09 16:48:16 momjian Exp $
+ * $Id: Connection.java,v 1.9 2000/10/12 08:55:24 peter Exp $
 *
 * This abstract class is used by org.postgresql.Driver to open either the JDBC1 or
 * JDBC2 versions of the Connection class.
@@ -82,6 +82,11 @@ public abstract class Connection
    public int pid;
    public int ckey;
+    // This receive_sbuf should be used by the different methods
+    // that call pg_stream.ReceiveString() in this Connection, so 
+    // so we avoid uneccesary new allocations. 
+    byte receive_sbuf[] = new byte[8192];
    /**
     * This is called by Class.forName() from within org.postgresql.Driver
     */
@@ -165,7 +170,7 @@ public abstract class Connection
 		// "User authentication failed"
 		//
 		throw new SQLException(pg_stream.ReceiveString
-                                       (4096, getEncoding()));
+                                       (receive_sbuf, 4096, getEncoding()));
 	      case 'R':
 		// Get the type of request
@@ -236,7 +241,7 @@ public abstract class Connection
 	case 'E':
 	case 'N':
           throw new SQLException(pg_stream.ReceiveString
-                                  (4096, getEncoding()));
+                                  (receive_sbuf, 4096, getEncoding()));
        default:
          throw new PSQLException("postgresql.con.setup");
      }
@@ -248,7 +253,7 @@ public abstract class Connection
 	   break;
 	case 'E':
 	case 'N':
-           throw new SQLException(pg_stream.ReceiveString(4096));
+           throw new SQLException(pg_stream.ReceiveString(receive_sbuf, 4096, getEncoding()));
        default:
          throw new PSQLException("postgresql.con.setup");
      }
@@ -322,6 +327,12 @@ public abstract class Connection
    {
 	// added Oct 7 1998 to give us thread safety.
 	synchronized(pg_stream) {
+ 	    // Deallocate all resources in the stream associated
+  	    // with a previous request.
+  	    // This will let the driver reuse byte arrays that has already
+  	    // been allocated instead of allocating new ones in order
+  	    // to gain performance improvements.
+  	    pg_stream.deallocate();	    
 	    Field[] fields = null;
 	    Vector tuples = new Vector();
@@ -353,7 +364,7 @@ public abstract class Connection
 		{
 		    pg_stream.SendChar('Q');
 		    buf = sql.getBytes();
-		    pg_stream.Send(buf);
+		    pg_stream.Send(sql.getBytes());
 		    pg_stream.SendChar(0);
 		    pg_stream.flush();
 		} catch (IOException e) {
@@ -370,7 +381,7 @@ public abstract class Connection
 			{
 			case 'A':	// Asynchronous Notify
 			    pid = pg_stream.ReceiveInteger(4);
-			    msg = pg_stream.ReceiveString(8192);
+			    msg = pg_stream.ReceiveString(receive_sbuf,8192,getEncoding());
 			    break;
 			case 'B':	// Binary Data Transfer
 			    if (fields == null)
@@ -381,7 +392,7 @@ public abstract class Connection
 				tuples.addElement(tup);
 			    break;
 			case 'C':	// Command Status
-			    recv_status = pg_stream.ReceiveString(8192);
+			    recv_status = pg_stream.ReceiveString(receive_sbuf,8192,getEncoding());
 				// Now handle the update count correctly.
 				if(recv_status.startsWith("INSERT") || recv_status.startsWith("UPDATE") || recv_status.startsWith("DELETE")) {
@@ -423,7 +434,7 @@ public abstract class Connection
 				tuples.addElement(tup);
 			    break;
 			case 'E':	// Error Message
-			    msg = pg_stream.ReceiveString(4096);
+			    msg = pg_stream.ReceiveString(receive_sbuf,4096,getEncoding());
 			    final_error = new SQLException(msg);
 			    hfr = true;
 			    break;
@@ -438,10 +449,10 @@ public abstract class Connection
 				hfr = true;
 			    break;
 			case 'N':	// Error Notification
-			    addWarning(pg_stream.ReceiveString(4096));
+			    addWarning(pg_stream.ReceiveString(receive_sbuf,4096,getEncoding()));
 			    break;
 			case 'P':	// Portal Name
-			    String pname = pg_stream.ReceiveString(8192);
+			    String pname = pg_stream.ReceiveString(receive_sbuf,8192,getEncoding());
 			    break;
 			case 'T':	// MetaData Field Description
 			    if (fields != null)
@@ -474,7 +485,7 @@ public abstract class Connection
 	for (i = 0 ; i < nf ; ++i)
 	    {
-		String typname = pg_stream.ReceiveString(8192);
+		String typname = pg_stream.ReceiveString(receive_sbuf,8192,getEncoding());
 		int typid = pg_stream.ReceiveIntegerR(4);
 		int typlen = pg_stream.ReceiveIntegerR(2);
 		int typmod = pg_stream.ReceiveIntegerR(4);

--- a/src/interfaces/jdbc/org/postgresql/Driver.java
+++ b/src/interfaces/jdbc/org/postgresql/Driver.java
@@ -26,10 +26,6 @@ import org.postgresql.util.PSQLException;
 */
 public class Driver implements java.sql.Driver 
 {
-  // These should be in sync with the backend that the driver was
-  // distributed with
-  static final int MAJORVERSION = 7;
-  static final int MINORVERSION = 0;
  static 
  {
@@ -117,10 +113,8 @@ public class Driver implements java.sql.Driver
    if((props = parseURL(url,info))==null)
      return null;
-    DriverManager.println("Using "+DriverClass.connectClass);
    try {
-	org.postgresql.Connection con = (org.postgresql.Connection)(Class.forName(DriverClass.connectClass).newInstance());
+	org.postgresql.Connection con = (org.postgresql.Connection)(Class.forName("%JDBCCONNECTCLASS%").newInstance());
 	con.openConnection (host(), port(), props, database(), url, this);
 	return (java.sql.Connection)con;
    } catch(ClassNotFoundException ex) {
@@ -198,7 +192,7 @@ public class Driver implements java.sql.Driver
   */
  public int getMajorVersion()
  {
-    return MAJORVERSION;
+    return %MAJORVERSION%;
  }
  /**
@@ -208,7 +202,15 @@ public class Driver implements java.sql.Driver
   */
  public int getMinorVersion()
  {
-    return MINORVERSION;
+    return %MINORVERSION%;
+  }
+    /**
+     * Returns the VERSION variable from Makefile.global
+     */
+    public static String getVersion()
+    {
+	return "%VERSION%";
    }
  /**

--- a/src/interfaces/jdbc/org/postgresql/PG_Stream.java
+++ b/src/interfaces/jdbc/org/postgresql/PG_Stream.java
@@ -23,6 +23,9 @@ public class PG_Stream
  private InputStream pg_input;
  private BufferedOutputStream pg_output;
+    BytePoolDim1 bytePoolDim1 = new BytePoolDim1();
+    BytePoolDim2 bytePoolDim2 = new BytePoolDim2();
  /**
   * Constructor:  Connect to the PostgreSQL back end and return
   * a stream connection.
@@ -70,7 +73,7 @@ public class PG_Stream
   */
  public void SendInteger(int val, int siz) throws IOException
  {
-    byte[] buf = new byte[siz];
+    byte[] buf = bytePoolDim1.allocByte(siz);
    while (siz-- > 0)
      {
@@ -94,7 +97,7 @@ public class PG_Stream
   */
  public void SendIntegerReverse(int val, int siz) throws IOException
  {
-    byte[] buf = new byte[siz];
+    byte[] buf = bytePoolDim1.allocByte(siz);
    int p=0;
    while (siz-- > 0)
      {
@@ -236,8 +239,19 @@ public class PG_Stream
      return n;
  }
-    public String ReceiveString(int maxsize) throws SQLException {
+  /**
-        return ReceiveString(maxsize, null);
+   * Receives a null-terminated string from the backend.  Maximum of
+   * maxsiz bytes - if we don't see a null, then we assume something
+   * has gone wrong.
+   *
+   * @param maxsiz maximum length of string
+   * @return string from back end
+   * @exception SQLException if an I/O error occurs
+   */
+  public String ReceiveString(int maxsiz) throws SQLException
+  {
+    byte[] rst = bytePoolDim1.allocByte(maxsiz);
+    return ReceiveString(rst, maxsiz, null);
  }
  /**
@@ -245,6 +259,7 @@ public class PG_Stream
   * maxsiz bytes - if we don't see a null, then we assume something
   * has gone wrong.
   *
+   * @param maxsiz maximum length of string
   * @param encoding the charset encoding to use.
   * @param maxsiz maximum length of string in bytes
   * @return string from back end
@@ -252,7 +267,25 @@ public class PG_Stream
   */
  public String ReceiveString(int maxsiz, String encoding) throws SQLException
  {
-    byte[] rst = new byte[maxsiz];
+    byte[] rst = bytePoolDim1.allocByte(maxsiz);
+    return ReceiveString(rst, maxsiz, encoding);
+  }
+  /**
+   * Receives a null-terminated string from the backend.  Maximum of
+   * maxsiz bytes - if we don't see a null, then we assume something
+   * has gone wrong.
+   *
+   * @param rst byte array to read the String into. rst.length must 
+   *        equal to or greater than maxsize. 
+   * @param maxsiz maximum length of string in bytes
+   * @param encoding the charset encoding to use.
+   * @return string from back end
+   * @exception SQLException if an I/O error occurs
+   */
+  public String ReceiveString(byte rst[], int maxsiz, String encoding) 
+      throws SQLException
+  {
    int s = 0;
    try
@@ -262,9 +295,10 @@ public class PG_Stream
 	    int c = pg_input.read();
 	    if (c < 0)
 	      throw new PSQLException("postgresql.stream.eof");
-	    else if (c == 0)
+ 	    else if (c == 0) {
+ 		rst[s] = 0;
 		break;
-	    else
+ 	    } else
 	      rst[s++] = (byte)c;
 	  }
 	if (s >= maxsiz)
@@ -299,7 +333,7 @@ public class PG_Stream
  {
    int i, bim = (nf + 7)/8;
    byte[] bitmask = Receive(bim);
-    byte[][] answer = new byte[nf][0];
+    byte[][] answer = bytePoolDim2.allocByte(nf);
    int whichbit = 0x80;
    int whichbyte = 0;
@@ -337,7 +371,7 @@ public class PG_Stream
   */
  private byte[] Receive(int siz) throws SQLException
  {
-    byte[] answer = new byte[siz];
+      byte[] answer = bytePoolDim1.allocByte(siz);
    Receive(answer,0,siz);
    return answer;
  }
@@ -395,4 +429,152 @@ public class PG_Stream
    pg_input.close();
    connection.close();
  }
+  /**
+   * Deallocate all resources that has been associated with any previous
+   * query.
+   */
+  public void deallocate(){
+      bytePoolDim1.deallocate();
+      bytePoolDim2.deallocate();
+  }
 }
+/**
+ * A simple and fast object pool implementation that can pool objects 
+ * of any type. This implementation is not thread safe, it is up to the users
+ * of this class to assure thread safety. 
+ */
+class ObjectPool {
+    int cursize = 0;
+    int maxsize = 16;
+    Object arr[] = new Object[maxsize];
+    public void add(Object o){
+	if(cursize >= maxsize){
+	    Object newarr[] = new Object[maxsize*2];
+	    System.arraycopy(arr, 0, newarr, 0, maxsize);
+	    maxsize = maxsize * 2;
+	    arr = newarr;
+	}
+	arr[cursize++] = o;
+    }
+    public Object remove(){
+	return arr[--cursize];
+    }
+    public boolean isEmpty(){
+	return cursize == 0;
+    }
+    public int size(){
+	return cursize;
+    }
+    public void addAll(ObjectPool pool){
+	int srcsize = pool.size();
+	if(srcsize == 0)
+	    return;
+	int totalsize = srcsize + cursize;
+	if(totalsize > maxsize){
+	    Object newarr[] = new Object[totalsize*2];
+	    System.arraycopy(arr, 0, newarr, 0, cursize);
+	    maxsize = maxsize = totalsize * 2;
+	    arr = newarr;
+	}
+	System.arraycopy(pool.arr, 0, arr, cursize, srcsize);
+	cursize = totalsize;
+    }
+    public void clear(){
+	    cursize = 0;
+    }
+}
+/**
+ * A simple and efficient class to pool one dimensional byte arrays
+ * of different sizes.
+ */
+class BytePoolDim1 {
+    int maxsize = 256;
+    ObjectPool notusemap[] = new ObjectPool[maxsize];
+    ObjectPool inusemap[] = new ObjectPool[maxsize];
+    byte binit[][] = new byte[maxsize][0];
+    public BytePoolDim1(){
+	for(int i = 0; i < maxsize; i++){
+	    binit[i] = new byte[i];
+	    inusemap[i] = new ObjectPool();
+	    notusemap[i] = new ObjectPool();
+	}
+    }
+    public byte[] allocByte(int size){
+	if(size > maxsize){
+	    return new byte[size];
+	}
+	ObjectPool not_usel = notusemap[size];
+	ObjectPool in_usel = inusemap[size];
+	byte b[] = null;
+	if(!not_usel.isEmpty()) {
+	    Object o = not_usel.remove();
+	    b = (byte[]) o;
+	} else 
+	    b = new byte[size];
+	in_usel.add(b);
+	return b;
+    }
+    public void deallocate(){
+	for(int i = 0; i < maxsize; i++){
+	    notusemap[i].addAll(inusemap[i]);
+	    inusemap[i].clear();
+	}
+    }
+}
+/**
+ * A simple and efficient class to pool two dimensional byte arrays
+ * of different sizes.
+ */
+class BytePoolDim2 {
+    int maxsize = 32;
+    ObjectPool notusemap[] = new ObjectPool[maxsize];
+    ObjectPool inusemap[] = new ObjectPool[maxsize];
+    public BytePoolDim2(){
+	for(int i = 0; i < maxsize; i++){
+	    inusemap[i] = new ObjectPool();
+	    notusemap[i] = new ObjectPool();
+	}
+    }
+    public byte[][] allocByte(int size){
+	if(size > maxsize){
+	    return new byte[size][0];
+	}
+	ObjectPool not_usel = notusemap[size];
+	ObjectPool in_usel =  inusemap[size];
+	byte b[][] = null;
+	if(!not_usel.isEmpty()) {
+	    Object o = not_usel.remove();
+	    b = (byte[][]) o;
+	} else 
+	    b = new byte[size][0];
+	in_usel.add(b);
+	return b;
+    }
+    public void deallocate(){
+	for(int i = 0; i < maxsize; i++){
+	    notusemap[i].addAll(inusemap[i]);
+	    inusemap[i].clear();
+	}
+    }
+}
--- a/src/interfaces/jdbc/org/postgresql/PostgresqlDataSource.java
+++ b/src/interfaces/jdbc/org/postgresql/PostgresqlDataSource.java
+/**
+ * Redistribution and use of this software and associated documentation
+ * ("Software"), with or without modification, are permitted provided
+ * that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain copyright
+ *    statements and notices.  Redistributions must also contain a
+ *    copy of this document.
+ *
+ * 2. Redistributions in binary form must reproduce the
+ *    above copyright notice, this list of conditions and the
+ *    following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ *
+ * 3. The name "Exolab" must not be used to endorse or promote
+ *    products derived from this Software without prior written
+ *    permission of Exoffice Technologies.  For written permission,
+ *    please contact info@exolab.org.
+ *
+ * 4. Products derived from this Software may not be called "Exolab"
+ *    nor may "Exolab" appear in their names without prior written
+ *    permission of Exoffice Technologies. Exolab is a registered
+ *    trademark of Exoffice Technologies.
+ *
+ * 5. Due credit should be given to the Exolab Project
+ *    (http://www.exolab.org/).
+ *
+ * THIS SOFTWARE IS PROVIDED BY EXOFFICE TECHNOLOGIES AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT
+ * NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * EXOFFICE TECHNOLOGIES OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Copyright 1999 (C) Exoffice Technologies Inc. All Rights Reserved.
+ *
+ * $Id: PostgresqlDataSource.java,v 1.1 2000/10/12 08:55:24 peter Exp $
+ */
+package org.postgresql;
+import java.io.PrintWriter;
+import java.io.Serializable;
+import java.util.Properties;
+import java.util.Hashtable;
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.sql.DriverManager;
+import java.rmi.Remote;
+import javax.sql.DataSource;
+import javax.naming.Referenceable;
+import javax.naming.Reference;
+import javax.naming.StringRefAddr;
+import javax.naming.RefAddr;
+import javax.naming.Context;
+import javax.naming.Name;
+import javax.naming.NamingException;
+import javax.naming.spi.ObjectFactory;
+import postgresql.util.PSQLException;
+import postgresql.xa.XADataSourceImpl;
+/**
+ * Implements a JDBC 2.0 {@link javax.sql.DataSource} for the
+ * PostgreSQL driver with JNDI persistance support. XA and pooled
+ * connection support is also available, but the application must
+ * used the designated DataSource interface to obtain them.
+ * <p>
+ * The supported data source properties are:
+ * <pre>
+ * description         (optional)
+ * databaseName        (required)
+ * loginTimeout        (optional)
+ * user                (optional)
+ * password            (optional)
+ * serverName          (optional)
+ * portNumber          (optional)
+ * transactionTimeout  (optional for XA connections)
+ * </pre>
+ * This data source may be serialized and stored in a JNDI
+ * directory. Example of how to create a new data source and
+ * register it with JNDI:
+ * <pre>
+ * PostgresqlDataSource ds;
+ * InitialContext       ctx;
+ *
+ * ds = new PostgresqlDataSource();
+ * ds.setDatabaseName( "test" );
+ * ds.setUser( "me" );
+ * ds.setPassword( "secret" );
+ * ctx = new InitialContext();
+ * ctx.rebind( "/comp/jdbc/test", ds );
+ * </pre>
+ * Example for obtaining the data source from JNDI and
+ * opening a new connections:
+ * <pre>
+ * InitialContext       ctx;
+ * DataSource           ds;
+ * 
+ * ctx = new InitialContext();
+ * ds = (DataSource) ctx.lookup( "/comp/jdbc/test" );
+ * ds.getConnection();
+ * </pre>
+ *
+ *
+ * @author <a href="arkin@exoffice.com">Assaf Arkin</a>
+ * @version 1.0
+ * @see XADataSourceImpl
+ * @see DataSource
+ * @see Connection
+ */
+public class PostgresqlDataSource
+    extends XADataSourceImpl
+    implements DataSource, Referenceable,
+	       ObjectFactory, Serializable
+{
+    /**
+     * Holds the timeout for opening a new connection, specified
+     * in seconds. The default is obtained from the JDBC driver.
+     */
+    private int _loginTimeout;
+    /**
+     * Holds the user's account name.
+     */
+    private String _user;
+    /**
+     * Holds the database password.
+     */
+    private String _password;
+    /**
+     * Holds the name of the particular database on the server.
+     */
+    private String _databaseName;
+    /**
+     * Description of this datasource.
+     */
+    private String _description = "PostgreSQL DataSource";
+    /**
+     * Holds the database server name. If null, this is
+     * assumed to be the localhost.
+     */
+    private String _serverName;
+    /**
+     * Holds the port number where a server is listening.
+     * The default value will open a connection with an
+     * unspecified port.
+     */
+    private int _portNumber = DEFAULT_PORT;
+    /**
+     * The default port number. Since we open the connection
+     * without specifying the port if it's the default one,
+     * this value can be meaningless.
+     */
+    private static final int DEFAULT_PORT = 0;
+    /**
+     * Holds the log writer to which all messages should be
+     * printed. The default writer is obtained from the driver
+     * manager, but it can be specified at the datasource level
+     * and will be passed to the driver. May be null.
+     */    
+    private transient PrintWriter _logWriter;
+    /**
+     * Each datasource maintains it's own driver, in case of
+     * driver-specific setup (e.g. pools, log writer).
+     */
+    private transient postgresql.Driver _driver;
+    public PostgresqlDataSource()
+    {
+	_logWriter = DriverManager.getLogWriter();
+	_loginTimeout = DriverManager.getLoginTimeout();
+    }
+    public Connection getConnection()
+        throws SQLException
+    {
+	// Uses the username and password specified for the datasource.
+	return getConnection( _user, _password );
+    }
+    public synchronized Connection getConnection( String user, String password )
+        throws SQLException
+    {
+	Connection conn;
+	Properties info;
+	String     url;
+	if ( _driver == null ) {
+	    try {
+		// Constructs a driver for use just by this data source
+		// which will produce TwoPhaseConnection-s. This driver
+		// is not registered with the driver manager.
+		_driver = new postgresql.Driver();
+		_driver.setLogWriter( _logWriter );
+	    } catch ( SQLException except ) {
+		if ( _logWriter != null )
+		    _logWriter.println( "DataSource: Failed to initialize JDBC driver: " + except );
+		throw except;
+	    }
+	}
+	// Use info to supply properties that are not in the URL.
+	info = new Properties();
+	info.put( "loginTimeout", Integer.toString( _loginTimeout ) );
+	// DriverManager will do that and not rely on the URL alone.
+	if ( user == null ) {
+	    user = _user;
+	    password = _password;
+	}
+	if ( user == null || password == null )
+	    throw new PSQLException( "postgresql.ds.userpswd" );
+	info.put( "user", user );
+	info.put( "password", password );
+        if ( _serverName != null )
+            info.put( "PGHOST", _serverName );
+        if ( _portNumber != DEFAULT_PORT )
+            info.put( "PGPORT", Integer.toString( _portNumber ) );
+        if ( _databaseName != null )
+            info.put( "PGDBNAME", _databaseName );
+	// Construct the URL suitable for this driver.
+	url = "jdbc:postgresql:";
+	// Attempt to establish a connection. Report a successful
+	// attempt or a failure.
+	try {
+	    conn = _driver.connect( url, info );
+	    if ( ! ( conn instanceof postgresql.jdbc2.Connection ) ) {
+		if ( _logWriter != null )
+		    _logWriter.println( "DataSource: JDBC 1 connections not supported" );
+		throw new PSQLException( "postgresql.ds.onlyjdbc2" );
+	    }
+	} catch ( SQLException except ) {
+	    if ( _logWriter != null )
+		_logWriter.println( "DataSource: getConnection failed " + except );
+	    throw except;
+	}
+	if ( conn != null && _logWriter != null )
+	    _logWriter.println( "DataSource: getConnection returning " + conn );
+	return conn;
+    }
+    public PrintWriter getLogWriter()
+    {
+	return _logWriter;
+    }
+    public synchronized void setLogWriter( PrintWriter writer )
+    {
+	// Once a log writer has been set, we cannot set it since some
+	// thread might be conditionally accessing it right now without
+	// synchronizing.
+	if ( writer != null ) {
+	    if ( _driver != null )
+		_driver.setLogWriter( writer );
+	    _logWriter = writer;
+	}
+    }
+    public void setLoginTimeout( int seconds )
+    {
+	_loginTimeout = seconds;
+    }
+    public synchronized int getLoginTimeout()
+    {
+	return _loginTimeout;
+    }
+    /**
+     * Sets the name of the particular database on the server.
+     * The standard name for this property is <tt>databaseName</tt>.
+     *
+     * @param databaseName The name of the particular database on the server
+     */
+    public synchronized void setDatabaseName( String databaseName )
+    {
+	if ( databaseName == null )
+	    throw new NullPointerException( "DataSource: Argument 'databaseName' is null" );
+	_databaseName = databaseName;
+    }
+    /**
+     * Returns the name of the particular database on the server.
+     * The standard name for this property is <tt>databaseName</tt>.
+     *
+     * @return The name of the particular database on the server
+     */
+    public String getDatabaseName()
+    {
+	return _databaseName;
+    }
+    /**
+     * Sets the description of this datasource.
+     * The standard name for this property is <tt>description</tt>.
+     *
+     * @param description The description of this datasource
+     */
+    public synchronized void setDescription( String description )
+    {
+	if ( description == null )
+	    throw new NullPointerException( "DataSource: Argument 'description' is null" );
+	_description = description;
+    }
+    /**
+     * Returns the description of this datasource.
+     * The standard name for this property is <tt>description</tt>.
+     *
+     * @return The description of this datasource
+     */
+    public String getDescription()
+    {
+	return _description;
+    }
+    /**
+     * Sets the database password.
+     * The standard name for this property is <tt>password</tt>.
+     *
+     * @param password The database password
+     */
+    public synchronized void setPassword( String password )
+    {
+	_password = password;
+    }
+    /**
+     * Returns the database password.
+     * The standard name for this property is <tt>password</tt>.
+     *
+     * @return The database password
+     */
+    public String getPassword()
+    {
+	return _password;
+    }
+    /**
+     * Sets the port number where a server is listening.
+     * The standard name for this property is <tt>portNumber</tt>.
+     *
+     * @param portNumber The port number where a server is listening
+     */
+    public synchronized void setPortNumber( int portNumber )
+    {
+	_portNumber = portNumber;
+    }
+    /**
+     * Returns the port number where a server is listening.
+     * The standard name for this property is <tt>portNumber</tt>.
+     *
+     * @return The port number where a server is listening
+     */
+    public int getPortNumber()
+    {
+	return _portNumber;
+    }
+    /**
+     * Sets the database server name.
+     * The standard name for this property is <tt>serverName</tt>.
+     *
+     * @param serverName The database server name
+     */
+    public synchronized void setServerName( String serverName )
+    {
+	_serverName = serverName;
+    }
+    /**
+     * Returns the database server name.
+     * The standard name for this property is <tt>serverName</tt>.
+     *
+     * @return The database server name
+     */
+    public String getServerName()
+    {
+	return _serverName;
+    }
+    /**
+     * Sets the user's account name.
+     * The standard name for this property is <tt>user</tt>.
+     *
+     * @param user The user's account name
+     */
+    public synchronized void setUser( String user )
+    {
+	_user = user;
+    }
+    /**
+     * Returns the user's account name.
+     * The standard name for this property is <tt>user</tt>.
+     *
+     * @return The user's account name
+     */
+    public String getUser()
+    {
+	return _user;
+    }
+    /**
+     * Returns true if this datasource and the other are equal.
+     * The two datasources are equal if and only if they will produce
+     * the exact same connections. Connection properties like database
+     * name, user name, etc are comapred. Setup properties like
+     * description, log writer, etc are not compared.
+     */
+    public synchronized boolean equals( Object other )
+    {
+	if ( other == this )
+	    return true;
+	if ( other == null || ! ( other instanceof PostgresqlDataSource ) )
+	    return false;
+	PostgresqlDataSource with;
+	with = (PostgresqlDataSource) other;
+	if ( _databaseName != null && _databaseName.equals( with._databaseName ) )
+	    if ( _portNumber == with._portNumber && 
+		 ( ( _serverName == null && with._serverName == null ) ||
+		   ( _serverName != null && _serverName.equals( with._serverName ) ) ) )
+		if ( ( _user == null && with._user == null ) ||
+		     ( _user != null && _password != null && _user.equals( with._user ) &&
+		       _password.equals( with._password ) ) )
+		    return true;
+	return false;
+    }
+    public String toString()
+    {
+	if ( _description != null )
+	    return _description;
+	else {
+	    String url;
+	    url = "jdbc:postgresql:";
+	    if ( _serverName != null ) {
+		if ( _portNumber == DEFAULT_PORT )
+		    url = url + "//" + _serverName + "/";
+		else
+		    url = url + "//" + _serverName + ":" + _portNumber + "/";
+	    } else if ( _portNumber != DEFAULT_PORT )
+		url = url + "//localhost:" + _portNumber + "/";
+	    if ( _databaseName != null )
+		url = url + _databaseName;
+	    return "DataSource " + url;
+	}
+    }
+    public synchronized Reference getReference()
+    {
+	Reference ref;
+	// We use same object as factory.
+	ref = new Reference( getClass().getName(), getClass().getName(), null );
+	// Mandatory properties
+	ref.add( new StringRefAddr( "description", _description ) );
+	ref.add( new StringRefAddr( "databaseName", _databaseName ) );
+	ref.add( new StringRefAddr( "loginTimeout", Integer.toString( _loginTimeout ) ) );
+	// Optional properties
+	if ( _user != null )
+	    ref.add( new StringRefAddr( "user", _user ) );
+	if ( _password != null )
+	    ref.add( new StringRefAddr( "password", _password ) );
+	if ( _serverName != null )
+	    ref.add( new StringRefAddr( "serverName", _serverName ) );
+	if ( _portNumber != DEFAULT_PORT )
+	    ref.add( new StringRefAddr( "portNumber", Integer.toString( _portNumber ) ) );
+	ref.add( new StringRefAddr( "transactionTimeout", Integer.toString( getTransactionTimeout() ) ) );
+ 	return ref;
+    }
+    public Object getObjectInstance( Object refObj, Name name, Context nameCtx, Hashtable env )
+        throws NamingException
+    {
+	Reference ref;
+	// Can only reconstruct from a reference.
+	if ( refObj instanceof Reference ) {
+	    ref = (Reference) refObj;
+	    // Make sure reference is of datasource class.
+	    if ( ref.getClassName().equals( getClass().getName() ) ) {
+		PostgresqlDataSource ds;
+		RefAddr              addr;
+		try {
+		    ds = (PostgresqlDataSource) Class.forName( ref.getClassName() ).newInstance();
+		} catch ( Exception except ) {
+		    throw new NamingException( except.toString() );
+		}
+		// Mandatory properties
+		ds._description = (String) ref.get( "description" ).getContent();
+		ds._databaseName = (String) ref.get( "databaseName" ).getContent();
+		ds._loginTimeout = Integer.parseInt( (String) ref.get( "loginTimeout" ).getContent() );
+		// Optional properties
+		addr = ref.get( "user" );
+		if ( addr != null )
+		    ds._user = (String) addr.getContent();
+		addr = ref.get( "password" );
+		if ( addr != null )
+		    ds._password = (String) addr.getContent();
+		addr = ref.get( "serverName" );
+		if ( addr != null )
+		    ds._serverName = (String) addr.getContent();
+		addr = ref.get( "portNumber" );
+		if ( addr != null )
+		    ds._portNumber = Integer.parseInt( (String) addr.getContent() );
+		addr = ref.get( "transactionTimeout" );
+		if ( addr != null )
+		    setTransactionTimeout( Integer.parseInt( (String) addr.getContent() ) );
+		return ds;
+	    } else
+		throw new NamingException( "DataSource: Reference not constructed from class " + getClass().getName() );
+	} else if ( refObj instanceof Remote )
+	    return refObj;
+	else
+	    return null;
+    }
+}
--- a/src/interfaces/jdbc/org/postgresql/errors.properties
+++ b/src/interfaces/jdbc/org/postgresql/errors.properties
 # This is the default errors
+postgresql.drv.version:An internal error has occured. Please recompile the driver.
 postgresql.con.auth:The authentication type {0} is not supported. Check that you have configured the pg_hba.conf file to include the client's IP address or Subnet, and that it is using an authentication scheme supported by the driver.
 postgresql.con.authfail:An error occured while getting the authentication request.
 postgresql.con.call:Callable Statements are not supported at this time.

--- a/src/interfaces/jdbc/org/postgresql/errors_it.properties
+++ b/src/interfaces/jdbc/org/postgresql/errors_it.properties
+# This is the italian version of some errors. Errors not in this file
+# are handled by the parent errors.properties file.
+#
+# Daniele Arduini <darduini@deis.unibo.it>
+# Wed Aug  9 12:18:31 CEST 2000
+#
+postgresql.con.auth:L'autenticazione di tipo {0} non è supportata. Verificare che nel file di configurazione pg_hba.conf sia presente l'indirizzo IP o la sotto-rete del client, e che lo schema di autenticazione utilizzato sia supportato dal driver.
+postgresql.con.authfail:Si è verificato un errore durante la richiesta di autenticazione.
+postgresql.con.call:I ``Callable Statements'' non sono supportati al momento. 
+postgresql.con.creobj:Fallita la creazione dell'oggetto per {0} {1}
+postgresql.con.failed:Il tentativo di connessione è fallito perché {0}
+#postgresql.con.fathom:Unable to fathom update count {0}
+postgresql.con.garbled:Ricevuti dati incomprensibili.
+postgresql.con.ioerror:Si è verificato un errore di I/O nella spedizione di dati al backend - {0}
+postgresql.con.kerb4:L'autenticazione di tipo ``Kerberos 4'' non è supportata da questo driver.
+postgresql.con.kerb5:L'autenticazione di tipo ``Kerberos 5'' non è supportata da questo driver.
+postgresql.con.multres:Impossibile gestire gruppi multipli di risultati.
+postgresql.con.pass:La proprietà ``password'' è mancante. E` obbligatoria.
+postgresql.con.refused:Connessione rifiutata. Controllare che il nome dell'host e la porta siano corretti, e che il server (postmaster) è in esecuzione con l'opzione -i, che abilita le connessioni attraverso la rete TCP/IP.
+postgresql.con.setup:Errore di protocollo. Fallita l'impostazione della sessione.
+postgresql.con.strobj:L'oggetto potrebbe non essere stato memorizzato. Controllare che ogni tabella richiesta è stata creata nel database.
+postgresql.con.strobjex:Fallita la memorizzazione dell'oggetto - {0}
+postgresql.con.toolong:L'istruzione SQL è troppo lunga - {0}
+postgresql.con.isolevel:Il livello d'isolamento delle transazioni {0} non è supportato.
+postgresql.con.tuple:Tupla ricevuta prima del MetaData.
+postgresql.con.type:Tipo di risposta sconosciuta {0}
+postgresql.con.user:La proprietà ``user'' è mancante. E` obbligatoria.
+postgresql.fp.error:La chiamata a FastPath ha restituito {0}
+postgresql.fp.expint:Chiamata Fastpath {0} - Nessun risultato restituito mentre ci si aspettava un intero.
+postgresql.fp.protocol:Errore nel protocollo FastPath: {0}
+postgresql.fp.send:Fallita la spedizione della chiamata fastpath {0} {1}
+postgresql.fp.unknown:La funzione fastpath {0} è sconosciuta.
+postgresql.geo.box:Fallita la conversione di un ``box'' - {0}
+postgresql.geo.circle:Fallita la conversione di un ``circle'' - {0}
+postgresql.geo.line:Fallita la conversione di una ``line'' - {0}
+postgresql.geo.lseg:Fallita la conversione di un ``lseg'' - {0}
+postgresql.geo.path:Impossibile stabilire se il ``path'' è aperto o chiuso.
+postgresql.geo.point:Fallita la conversione di un ``point'' - {0}
+postgresql.jvm.version:Il file ``postgresql.jar'' non contiene le classi JDBC corrette per questa JVM. Provare a ricompilarle. Se il problema persiste, tentare di forzare la versione fornendola nella linea di comando con l'opzione -Djava.version=1.1 or -Djava.version=1.2\nL'eccezione ricevuta è stata {0}
+postgresql.lo.init:Inizializzazione di LargeObject API fallita.
+postgresql.money:Fallita la conversione di un ``money'' - {0}.
+postgresql.prep.is:InputStream come parametro non è supportato
+postgresql.prep.param:Nessun valore specificato come parametro {0}.
+postgresql.prep.range:Indice di parametro fuori dall'intervallo.
+postgresql.prep.type:Valore di tipo sconosciuto.
+postgresql.res.badbigdec:Cattivo BigDecimal {0}
+postgresql.res.badbyte:Cattivo Byte {0}
+postgresql.res.baddate:Cattivo Date Format a {0} in {1}
+postgresql.res.baddouble:Cattivo Double {0}
+postgresql.res.badfloat:Cattivo Float {0}
+postgresql.res.badint:Cattivo Integer {0}
+postgresql.res.badlong:Cattivo Long {0}
+postgresql.res.badshort:Cattivo Short {0}
+postgresql.res.badtime:Cattivo Time {0}
+postgresql.res.badtimestamp:Cattivo Timestamp Format a {0} in {1}
+postgresql.res.colname:Colonna denominata {0} non trovata.
+postgresql.res.colrange:Indice di colonna fuori dall'intervallo.
+postgresql.serial.interface:Impossibile serializzare una interfaccia.
+postgresql.serial.namelength:La lunghezza dei nomi per Class & Package non può essere superiore a 32 caratteri. {0} è di {1} caratteri.
+postgresql.serial.noclass:Nessuna classe trovata per {0}.
+postgresql.serial.table:La tabella per {0} non è nel database. Contattare il DBA, visto che il database è in uno stato incosistente.
+postgresql.serial.underscore:Il nome di una classe non può contenere il carattere ``_''. E` stato fornito {0}.
+postgresql.stat.batch.empty:La sequenza di operazioni è vuota. Non c'è niente da eseguire.
+postgresql.stat.batch.error:L'operazione {0} {1} della sequenza è stata annullata.
+postgresql.stat.maxfieldsize:Fallito un tentativo a setMaxFieldSize() - verrà utilizzato il valore predefinito a tempo di compilazione.
+postgresql.stat.noresult:Nessun risultato è stato restituito dalla query.
+postgresql.stat.result:Un risultato è stato restituito dallo statement, quando ci si aspettava nulla.
+postgresql.stream.eof:Il backend ha interrotto la connessione. Probabilmente la tua azione ha causato la sua uscita.
+postgresql.stream.flush:Si è verificato un errore di I/O mentre si svuotava il buffer d'uscita - {0}
+postgresql.stream.ioerror:Si è verificato un errore di I/O mentre si leggevano dati dal backend - {0}
+postgresql.stream.toomuch:Troppi dati ricevuti.
+postgresql.unusual:Qualcosa di insolito si è verificato causando il fallimento del driver. Per favore riferire allo sviluppatore questa eccezione: {0}
+postgresql.unimplemented:Questo metodo non è stato ancora implementato.
+postgresql.unexpected:Un risultato inaspettato è stato ricevuto dalla query.
--- a/src/interfaces/jdbc/org/postgresql/jdbc1/DatabaseMetaData.java
+++ b/src/interfaces/jdbc/org/postgresql/jdbc1/DatabaseMetaData.java
@@ -179,7 +179,7 @@ public class DatabaseMetaData implements java.sql.DatabaseMetaData
   */
  public String getDatabaseProductVersion() throws SQLException
  {
-    return ("7.0.2");
+      return connection.this_driver.getVersion();
  }
  /**
@@ -203,7 +203,7 @@ public class DatabaseMetaData implements java.sql.DatabaseMetaData
   */
  public String getDriverVersion() throws SQLException
  {
-    return Integer.toString(connection.this_driver.getMajorVersion())+"."+Integer.toString(connection.this_driver.getMinorVersion());
+      return connection.this_driver.getVersion();
  }
  /**
@@ -453,14 +453,14 @@ public class DatabaseMetaData implements java.sql.DatabaseMetaData
  /**
   * Is "ALTER TABLE" with a drop column supported?
-   * Yes for PostgreSQL 6.1
+   * Peter 10/10/2000 This was set to true, but 7.1devel doesn't support it!
   *
   * @return true if so
   * @exception SQLException if a database access error occurs
   */
  public boolean supportsAlterTableWithDropColumn() throws SQLException
  {
-    return true;
+      return false;
  }
  /**

--- a/src/interfaces/jdbc/org/postgresql/jdbc2/DatabaseMetaData.java
+++ b/src/interfaces/jdbc/org/postgresql/jdbc2/DatabaseMetaData.java
@@ -179,7 +179,7 @@ public class DatabaseMetaData implements java.sql.DatabaseMetaData
   */
  public String getDatabaseProductVersion() throws SQLException
  {
-    return ("7.0.2");
+      return connection.this_driver.getVersion();
  }
  /**
@@ -203,7 +203,7 @@ public class DatabaseMetaData implements java.sql.DatabaseMetaData
   */
  public String getDriverVersion() throws SQLException
  {
-    return Integer.toString(connection.this_driver.getMajorVersion())+"."+Integer.toString(connection.this_driver.getMinorVersion());
+      return connection.this_driver.getVersion();
  }
  /**
@@ -453,14 +453,14 @@ public class DatabaseMetaData implements java.sql.DatabaseMetaData
  /**
   * Is "ALTER TABLE" with a drop column supported?
-   * Yes for PostgreSQL 6.1
+   * Peter 10/10/2000 This was set to true, but 7.1devel doesn't support it!
   *
   * @return true if so
   * @exception SQLException if a database access error occurs
   */
  public boolean supportsAlterTableWithDropColumn() throws SQLException
  {
-    return true;
+      return false;
  }
  /**
@@ -523,7 +523,7 @@ public class DatabaseMetaData implements java.sql.DatabaseMetaData
  }
  /**
-   * Are expressions in "ORCER BY" lists supported?
+   * Are expressions in "ORDER BY" lists supported?
   * 
   * <br>e.g. select * from t order by a + b;
   *

--- a/src/interfaces/jdbc/org/postgresql/jdbc2/ResultSet.java
+++ b/src/interfaces/jdbc/org/postgresql/jdbc2/ResultSet.java
@@ -730,6 +730,11 @@ public class ResultSet extends org.postgresql.ResultSet implements java.sql.Resu
    if (columnIndex < 1 || columnIndex > fields.length)
      throw new PSQLException("postgresql.res.colrange");
+    wasNullFlag = (this_row[columnIndex - 1] == null);
+    if(wasNullFlag)
+      return null;
    field = fields[columnIndex - 1];
    // some fields can be null, mainly from those returned by MetaData methods

--- a/src/interfaces/jdbc/utils/CheckVersion.java
+++ b/src/interfaces/jdbc/utils/CheckVersion.java
+package utils;
+/**
+ * This little app checks to see what version of JVM is being used.
+ * It does this by checking first the java.vm.version property, and
+ * if that fails, it looks for certain classes that should be present.
+ */
+public class CheckVersion
+{
+    /**
+     * Check for the existence of a class by attempting to load it
+     */
+    public static boolean checkClass(String c) {
+	try {
+	    Class.forName(c);
+	} catch(Exception e) {
+	    return false;
+	}
+	return true;
+    }
+    /**
+     * This first checks java.vm.version for 1.1, 1.2 or 1.3.
+     *
+     * It writes jdbc1 to stdout for the 1.1.x VM.
+     *
+     * For 1.2 or 1.3, it checks for the existence of the javax.sql.DataSource
+     * interface, and if found writes enterprise to stdout. If the interface
+     * is not found, it writes jdbc2 to stdout.
+     *
+     * PS: It also looks for the existence of java.lang.Byte which appeared in
+     * JDK1.1.0 incase java.vm.version is not heeded by some JVM's.
+     *
+     * If it can't work it out, it writes huho to stdout.
+     *
+     * The make file uses the written results to determine which rule to run.
+     *
+     * Bugs: This needs thorough testing.
+     */
+    public static void main(String args[])
+    {
+	String vmversion = System.getProperty("java.vm.version");
+	// We are running a 1.1 JVM
+	if(vmversion.startsWith("1.1")) {
+	    System.out.println("jdbc1");
+	    System.exit(0);
+	}
+	// We are running a 1.2 or 1.3 JVM
+	if(vmversion.startsWith("1.2") ||
+	   vmversion.startsWith("1.3") ||
+	   checkClass("java.lang.Byte")
+	   ) {
+	    // Check to see if we have the standard extensions. If so, then
+	    // we want the enterprise edition, otherwise the jdbc2 driver.
+	    if(checkClass("javax.sql.DataSource"))
+		System.out.println("enterprise");
+	    else
+		System.out.println("jdbc2");
+	    System.exit(0);
+	}
+	System.out.println("huho");
+	System.exit(0);
+    }
+}
--- a/src/interfaces/jdbc/utils/buildDriver
+++ b/src/interfaces/jdbc/utils/buildDriver
+#!/bin/sh
+#
+# $Id: buildDriver,v 1.1 2000/10/12 08:55:28 peter Exp $
+#
+# This script generates the org/postgresql/Driver.java file from the template
+# org/postgresql/Driver.java.in
+#
+# We do this because we need to include the version number from Makefile.global
+# and some other goodies.
+#
+# This used to be in Makefile, but as it's now done three times, it's better
+# to have it as a separate script.
+#
+# If you have any problems, please let us know ;-)
+#
+# Syntax: buildDriver version class
+#
+# Where:
+#	version	The version string from Makefile.global
+#	class	The class implementing java.sql.Connection
+#	edition	The driver edition being built
+#	source	The file to build. We assume that ${source}.in exists
+#
+VERSION=$1
+CLASS=$2
+EDITION=$3
+SOURCE=$4
+#---------------------------------------------------------------------------
+# Extract the version. This will work until version x.9 (and assuming we don't
+# have 7.10 etc). We only handle 1 digit for MINORVERSION to handle things like
+# 7.1devel etc
+#
+MAJORVERSION=`echo $VERSION | cut -f1 -d'.'`
+MINORVERSION=`echo $VERSION | cut -f2 -d'.' | cut -c1`
+#---------------------------------------------------------------------------
+# Now finally build the driver
+sed \
+	-e "s/%JDBCCONNECTCLASS%/$CLASS/g" \
+	-e "s/%VERSION%/$VERSION $EDITION/g" \
+	-e "s/%MAJORVERSION%/$MAJORVERSION/g" \
+	-e "s/%MINORVERSION%/$MINORVERSION/g" \
+	<${SOURCE}.in \
+	>$SOURCE
+#---------------------------------------------------------------------------
--- a/src/interfaces/jdbc/utils/changelog.pl
+++ b/src/interfaces/jdbc/utils/changelog.pl
+#!/bin/perl
+while(<>) {
+    chomp();
+    s/\t+/ /g;
+    if(substr($_,0,3) eq ' - ') {
+	print "<ul>" if !$inlist;
+	$inlist=1;
+	print "<li>".substr($_,3)."\n";
+    } else {
+	if($_ eq "" || $_ eq " ") {
+	    print "</ul>" if $inlist;
+	    $inlist=0;
+	    print "<br>\n";
+	} elsif(substr($_,0,1) eq " ") {
+	    print $_;
+	} else {
+	    print "</ul>" if $inlist;
+	    $inlist=0;
+	    print "<h4>".$_."</h4>\n";
+	}
+    }
+}