Enhancements to how queries with bind values are stored internally and sent to

the server.  Previously we allocated a new String object for the entire final
query we were sending to the database.  If you had a big query, or especially
if you had large bind values you ended up with essentially two copies in memory.
This change will reuse the existing objects and therefore should take 1/2 the
memory it does today for a given query.  This restructuring will also allow
in the future the ability to stream bytea data to the server instead of the current approach of pulling it all into memory.
I also fixed a test that was failing on a 7.2 database.
Also renamed some internal variables and some minor cleanup.

 Modified Files:
 	jdbc/org/postgresql/core/QueryExecutor.java
 	jdbc/org/postgresql/jdbc1/AbstractJdbc1Connection.java
 	jdbc/org/postgresql/jdbc1/AbstractJdbc1Statement.java
 	jdbc/org/postgresql/jdbc2/AbstractJdbc2ResultSet.java
 	jdbc/org/postgresql/jdbc2/AbstractJdbc2Statement.java
 	jdbc/org/postgresql/test/jdbc2/DatabaseMetaDataTest.java

Author: Barry Lind

src/interfaces/jdbc/org/postgresql/core/QueryExecutor.java

@@ -13,24 +13,26 @@
  * <p>The lifetime of a QueryExecutor object is from sending the query
  * until the response has been received from the backend.
  *
- * $Id: QueryExecutor.java,v 1.13 2002/07/23 03:59:55 barry Exp $
+ * $Id: QueryExecutor.java,v 1.14 2002/08/23 20:45:49 barry Exp $
  */
 
 public class QueryExecutor
 {
 
-        private final String sql;
+        private final String[] m_sqlFrags;
+        private final Object[] m_binds;
         private final java.sql.Statement statement;
         private final PG_Stream pg_stream;
         private final org.postgresql.jdbc1.AbstractJdbc1Connection connection;
 
-        public QueryExecutor(String sql,
+    public QueryExecutor(String[] p_sqlFrags, Object[] p_binds,
                                                  java.sql.Statement statement,
                                                  PG_Stream pg_stream,
                                                  java.sql.Connection connection)
         throws SQLException
         {
-                this.sql = sql;
+                this.m_sqlFrags = p_sqlFrags;
+                this.m_binds = p_binds;
                 this.statement = statement;
                 this.pg_stream = pg_stream;
                 this.connection = (org.postgresql.jdbc1.AbstractJdbc1Connection)connection;
@@ -60,7 +62,7 @@ public java.sql.ResultSet execute() throws SQLException
                 synchronized (pg_stream)
                 {
 
-                        sendQuery(sql);
+                        sendQuery();
 
                         int c;
                         boolean l_endQuery = false;
@@ -129,12 +131,18 @@ public java.sql.ResultSet execute() throws SQLException
         /*
          * Send a query to the backend.
          */
-        private void sendQuery(String query) throws SQLException
+        private void sendQuery() throws SQLException
         {
                 try
                 {
                         pg_stream.SendChar('Q');
-                        pg_stream.Send(connection.getEncoding().encode(query));
+   	                for (int i = 0 ; i < m_binds.length ; ++i) {
+			  if (m_binds[i] == null)
+				throw new PSQLException("postgresql.prep.param", new Integer(i + 1));
+			  pg_stream.Send(connection.getEncoding().encode(m_sqlFrags[i]));
+                          pg_stream.Send(connection.getEncoding().encode(m_binds[i].toString()));
+		        }
+                        pg_stream.Send(connection.getEncoding().encode(m_sqlFrags[m_binds.length]));
                         pg_stream.SendChar(0);
                         pg_stream.flush();
 

src/interfaces/jdbc/org/postgresql/jdbc1/AbstractJdbc1Connection.java

@@ -13,7 +13,7 @@
 import org.postgresql.util.*;
 
 
-/* $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc1/Attic/AbstractJdbc1Connection.java,v 1.4 2002/08/16 19:34:57 davec Exp $
+/* $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc1/Attic/AbstractJdbc1Connection.java,v 1.5 2002/08/23 20:45:49 barry Exp $
  * This class defines methods of the jdbc1 specification.  This class is
  * extended by org.postgresql.jdbc2.AbstractJdbc2Connection which adds the jdbc2
  * methods.  The real Connection class (for jdbc1) is org.postgresql.jdbc1.Jdbc1Connection
@@ -426,7 +426,26 @@ public java.sql.ResultSet ExecSQL(String sql) throws SQLException
          */
         public java.sql.ResultSet ExecSQL(String sql, java.sql.Statement stat) throws SQLException
         {
-                return new QueryExecutor(sql, stat, pg_stream, (java.sql.Connection)this).execute();
+            return new QueryExecutor(new String[] {sql}, EMPTY_OBJECT_ARRAY, stat, pg_stream, (java.sql.Connection)this).execute();
+        }
+        private static final Object[] EMPTY_OBJECT_ARRAY = new Object[0];
+
+        /*
+         * Send a query to the backend.  Returns one of the ResultSet
+         * objects.
+         *
+         * <B>Note:</B> there does not seem to be any method currently
+         * in existance to return the update count.
+         *
+         * @param p_sqlFragmentss the SQL statement parts to be executed
+         * @param p_binds the SQL bind values
+         * @param stat The Statement associated with this query (may be null)
+         * @return a ResultSet holding the results
+         * @exception SQLException if a database error occurs
+         */
+        public java.sql.ResultSet ExecSQL(String[] p_sqlFragments, Object[] p_binds, java.sql.Statement stat) throws SQLException
+        {
+                return new QueryExecutor(p_sqlFragments, p_binds, stat, pg_stream, (java.sql.Connection)this).execute();
         }
 
         /*