diff -rcN -x'*.class' -x'*.jar' -x'*.swp' clean/build.xml kris5/build.xml
*** clean/build.xml	2006-07-03 09:58:10.000000000 -0600
--- kris5/build.xml	2006-11-26 03:04:26.000000000 -0700
***************
*** 325,330 ****
--- 325,331 ----
    <property name="preparethreshold" value="0" />
    <property name="loglevel" value="0" />
    <property name="protocolVersion" value="0" />
+   <property name="binaryEncoding" value="false" />
  
    <!-- The tests now build to a separate directory and jarfile from the
         driver build, to ensure we're really testing against the jar we just
***************
*** 365,370 ****
--- 366,372 ----
        <sysproperty key="preparethreshold" value="${preparethreshold}" />
        <sysproperty key="loglevel" value="${loglevel}" />
        <sysproperty key="protocolVersion" value="${protocolVersion}" />
+       <sysproperty key="binaryEncoding" value="${binaryEncoding}" />
  
        <classpath>
          <pathelement location="${jardir}/postgresql.jar" />
diff -rcN -x'*.class' -x'*.jar' -x'*.swp' clean/doc/pgjdbc.xml kris5/doc/pgjdbc.xml
*** clean/doc/pgjdbc.xml	2006-10-06 02:02:00.000000000 -0600
--- kris5/doc/pgjdbc.xml	2006-11-25 23:05:50.000000000 -0700
***************
*** 567,572 ****
--- 567,589 ----
        </varlistentry>
  
        <varlistentry>
+        <term><varname>binaryEncoding</varname> = <type>boolean</type></term>
+        <listitem>
+         <para>
+          The postgresql protocol v3 supports both binary and text transfer
+          of result set values. When binaryEncoding is enabled the driver
+          requests binary encoding for all supported types. Previously only
+          the text encoding was used and the old functionality can be reverted
+          setting this field to false.
+          Currently the following column types currently support binary encoding:
+          <literal>BYTEA</literal>, <literal>TIMEx</literal>,
+          <literal>TIMESTAMPx</literal>, <literal>DATE</literal>,
+          <literal>INTx</literal> and <literal>FLOATx</literal>.
+         </para>
+        </listitem>
+       </varlistentry>
+ 
+       <varlistentry>
         <term><varname>prepareThreshold</varname> = <type>int</type></term>
         <listitem>
          <para>
diff -rcN -x'*.class' -x'*.jar' -x'*.swp' clean/org/postgresql/core/Field.java kris5/org/postgresql/core/Field.java
*** clean/org/postgresql/core/Field.java	2006-10-06 02:31:44.000000000 -0600
--- kris5/org/postgresql/core/Field.java	2006-11-25 23:05:50.000000000 -0700
***************
*** 258,261 ****
--- 258,267 ----
                  ps.close();
          }
      }
+     
+     public String toString() {
+         return "Field("+ (columnName != null ? columnName : "") + "," +
+                 Oid.toString(oid) + "," + length + "," +
+                 (format == TEXT_FORMAT ? 'T' : 'B') + ")";
+     }
  }
diff -rcN -x'*.class' -x'*.jar' -x'*.swp' clean/org/postgresql/core/Oid.java kris5/org/postgresql/core/Oid.java
*** clean/org/postgresql/core/Oid.java	2005-12-04 13:14:26.000000000 -0700
--- kris5/org/postgresql/core/Oid.java	2006-11-25 23:05:50.000000000 -0700
***************
*** 9,14 ****
--- 9,16 ----
  */
  package org.postgresql.core;
  
+ import java.lang.reflect.Field;
+ 
  /**
   * Provides constants for well-known backend OIDs for the types we commonly
   * use.
***************
*** 39,43 ****
--- 41,66 ----
      public static final int INTERVAL = 1186;
      public static final int CHAR = 18; // This is not char(N), this is "char" a single byte type.
      public static final int VARBIT = 1562;
+     
+     /**
+      * Returns the name of the oid as string.
+      * 
+      * @param oid The oid to convert to name.
+      * @return The name of the oid or "<unknown>" if oid no constant for
+      * oid value has been defined.
+      */
+     public static String toString(int oid) {
+         try {
+             Field[] fields = Oid.class.getFields();
+             for (int i = 0; i < fields.length; ++i) {
+                 if (fields[i].getInt(null) == oid) {
+                     return fields[i].getName();
+                 }
+             }
+         } catch (IllegalAccessException e) {
+             // never happens
+         }
+         return "<unknown>";
+     }
  
  }
diff -rcN -x'*.class' -x'*.jar' -x'*.swp' clean/org/postgresql/core/ProtocolConnection.java kris5/org/postgresql/core/ProtocolConnection.java
*** clean/org/postgresql/core/ProtocolConnection.java	2005-06-21 12:07:08.000000000 -0600
--- kris5/org/postgresql/core/ProtocolConnection.java	2006-11-25 23:05:50.000000000 -0700
***************
*** 12,17 ****
--- 12,18 ----
  
  import org.postgresql.PGNotification;
  import java.sql.*;
+ import java.util.BitSet;
  
  /**
   * Provides access to protocol-level connection operations.
***************
*** 120,123 ****
--- 121,139 ----
       * @return the version of the implementation
       */
      public int getProtocolVersion();
+ 
+     /**
+      * Returns true if server uses integer instead of double for binary
+      * date and time encodings.
+      * 
+      * @return the server integer_datetime setting.
+      */
+     public boolean getIntegerDateTimes();
+ 
+     /**
+      * Sets the oids that should be received using binary encoding.
+      * 
+      * @param useBinaryForOids The oids to request with binary encoding.
+      */
+     public void setBinaryOids(BitSet useBinaryForOids);
  }
diff -rcN -x'*.class' -x'*.jar' -x'*.swp' clean/org/postgresql/core/v2/ProtocolConnectionImpl.java kris5/org/postgresql/core/v2/ProtocolConnectionImpl.java
*** clean/org/postgresql/core/v2/ProtocolConnectionImpl.java	2005-12-01 20:05:07.000000000 -0700
--- kris5/org/postgresql/core/v2/ProtocolConnectionImpl.java	2006-11-25 23:05:50.000000000 -0700
***************
*** 13,18 ****
--- 13,19 ----
  import java.sql.*;
  import java.io.IOException;
  import java.util.ArrayList;
+ import java.util.BitSet;
  
  import org.postgresql.PGNotification;
  import org.postgresql.core.*;
***************
*** 193,198 ****
--- 194,208 ----
          return 2;
      }
      
+     public boolean getIntegerDateTimes() {
+         // only matters if binary encoding is used
+         return false;
+     }
+     
+     public void setBinaryOids(BitSet ignored) {
+        // ignored for v2 connections
+     }
+ 
      private String serverVersion;
      private int cancelPid;
      private int cancelKey;
diff -rcN -x'*.class' -x'*.jar' -x'*.swp' clean/org/postgresql/core/v3/ConnectionFactoryImpl.java kris5/org/postgresql/core/v3/ConnectionFactoryImpl.java
*** clean/org/postgresql/core/v3/ConnectionFactoryImpl.java	2005-11-23 19:29:21.000000000 -0700
--- kris5/org/postgresql/core/v3/ConnectionFactoryImpl.java	2006-11-25 23:05:50.000000000 -0700
***************
*** 470,475 ****
--- 470,479 ----
                          throw new PSQLException(GT.tr("Protocol error.  Session setup failed."), PSQLState.CONNECTION_UNABLE_TO_CONNECT);
                      pgStream.setEncoding(Encoding.getDatabaseEncoding("UNICODE"));
                  }
+                 else if (name.equals("integer_datetimes"))
+                 {
+                     protoConnection.setIntegerDateTimes(value.equals("on"));
+                 }
  
                  break;
  
diff -rcN -x'*.class' -x'*.jar' -x'*.swp' clean/org/postgresql/core/v3/ProtocolConnectionImpl.java kris5/org/postgresql/core/v3/ProtocolConnectionImpl.java
*** clean/org/postgresql/core/v3/ProtocolConnectionImpl.java	2005-12-01 20:05:09.000000000 -0700
--- kris5/org/postgresql/core/v3/ProtocolConnectionImpl.java	2006-11-25 23:05:50.000000000 -0700
***************
*** 16,21 ****
--- 16,22 ----
  import java.sql.*;
  import java.io.IOException;
  import java.util.ArrayList;
+ import java.util.BitSet;
  import java.util.Properties;
  
  /**
***************
*** 189,194 ****
--- 190,223 ----
          return 3;
      }
  
+     public void setIntegerDateTimes(boolean state) {
+         integerDateTimes = state;
+     }
+     
+     public boolean getIntegerDateTimes() {
+         return integerDateTimes;
+     }
+     
+     public boolean useBinaryForReceive(int oid) {
+         return useBinaryForOids.get(oid);
+     }
+ 
+     public void setBinaryOids(BitSet oids) {
+         useBinaryForOids.clear();
+         useBinaryForOids.or(oids);
+     }
+     
+     /**
+      * Bit set that has a bit set for each oid which should be received
+      * using binary format.
+      */ 
+     private final BitSet useBinaryForOids = new BitSet();
+ 
+     /**
+      * True if server uses integers for date and time fields. False if
+      * server uses double.
+      */
+     private boolean integerDateTimes;
      private String serverVersion;
      private int cancelPid;
      private int cancelKey;
diff -rcN -x'*.class' -x'*.jar' -x'*.swp' clean/org/postgresql/core/v3/QueryExecutorImpl.java kris5/org/postgresql/core/v3/QueryExecutorImpl.java
*** clean/org/postgresql/core/v3/QueryExecutorImpl.java	2006-11-02 18:57:11.000000000 -0700
--- kris5/org/postgresql/core/v3/QueryExecutorImpl.java	2006-11-26 02:42:41.000000000 -0700
***************
*** 682,687 ****
--- 682,690 ----
          // Clean up any existing statement, as we can't use it.
          query.unprepare();
          processDeadParsedQueries();
+         
+         // Remove any cached Field values
+         query.setFields(null);
  
          String statementName = null;
          if (!oneShot)
***************
*** 805,816 ****
                  encodedSize += (long)4 + params.getV3Length(i);
          }
  
          encodedSize = 4
                        + (encodedPortalName == null ? 0 : encodedPortalName.length) + 1
                        + (encodedStatementName == null ? 0 : encodedStatementName.length) + 1
                        + 2 + params.getParameterCount() * 2
                        + 2 + encodedSize
!                       + 2;
  
          // backend's MaxAllocSize is the largest message that can
          // be received from a client.  If we have a bigger value
--- 808,834 ----
                  encodedSize += (long)4 + params.getV3Length(i);
          }
  
+         // This is not the number of binary fields, but the total number
+         // of fields if any of them are binary or zero if all of them
+         // are text.
+ 
+         int numBinaryFields = 0;
+         Field[] fields = query.getFields();
+         if (fields != null) {
+             for (int i = 0; i < fields.length; ++i) {
+                 if (useBinary(fields[i])) {
+                     fields[i].setFormat(Field.BINARY_FORMAT);
+                     numBinaryFields = fields.length;
+                 }
+             }
+         }
+         
          encodedSize = 4
                        + (encodedPortalName == null ? 0 : encodedPortalName.length) + 1
                        + (encodedStatementName == null ? 0 : encodedStatementName.length) + 1
                        + 2 + params.getParameterCount() * 2
                        + 2 + encodedSize
!                       + 2 + numBinaryFields * 2;
  
          // backend's MaxAllocSize is the largest message that can
          // be received from a client.  If we have a bigger value
***************
*** 865,871 ****
              }
          }
  
!         pgStream.SendInteger2(0);   // # of result format codes (0)
  
          pendingBindQueue.add(portal);
  
--- 883,892 ----
              }
          }
  
!         pgStream.SendInteger2(numBinaryFields);   // # of result format codes
!         for (int i = 0; i < numBinaryFields; ++i) {
!             pgStream.SendInteger2(fields[i].getFormat());
!         }
  
          pendingBindQueue.add(portal);
  
***************
*** 874,879 ****
--- 895,913 ----
              throw bindException;
          }
      }
+     
+     /**
+      * Returns true if the specified field should be retrieved using binary
+      * encoding.
+      *  
+      * @param field The field whose Oid type to analyse.  
+      * @return True if {@link Field#BINARY_FORMAT} should be used, false if
+      * {@link Field#BINARY_FORMAT}.
+      */
+     private boolean useBinary(Field field) {
+         int oid = field.getOID();
+         return protoConnection.useBinaryForReceive(oid);
+     }
  
      private void sendDescribePortal(Portal portal) throws IOException {
          //
***************
*** 1052,1059 ****
          // A statement describe will also output a RowDescription,
          // so don't reissue it here if we've already done so.
          //
!         if (!noMeta && !describeStatement)
!             sendDescribePortal(portal);
  
          sendExecute(query, portal, rows);
      }
--- 1086,1098 ----
          // A statement describe will also output a RowDescription,
          // so don't reissue it here if we've already done so.
          //
!         if (!noMeta && !describeStatement) {
!             // don't send describe if we already have cached the
!             // descriptionrow from previous executions
!             if (query.getFields() == null) {
!                 sendDescribePortal(portal);
!             }
!         }
  
          sendExecute(query, portal, rows);
      }
***************
*** 1251,1258 ****
  
                  {
                      Object[] executeData = (Object[])pendingExecuteQueue.get(executeIndex++);
!                     Query currentQuery = (Query)executeData[0];
                      Portal currentPortal = (Portal)executeData[1];
                      handler.handleResultRows(currentQuery, fields, tuples, currentPortal);
                  }
  
--- 1290,1305 ----
  
                  {
                      Object[] executeData = (Object[])pendingExecuteQueue.get(executeIndex++);
!                     SimpleQuery currentQuery = (SimpleQuery)executeData[0];
                      Portal currentPortal = (Portal)executeData[1];
+                     
+                     // use cached fields if available
+                     if (currentQuery.getFields() != null) {
+                         fields = currentQuery.getFields();
+                     } else {
+                         currentQuery.setFields(fields);
+                     }
+ 
                      handler.handleResultRows(currentQuery, fields, tuples, currentPortal);
                  }
  
***************
*** 1268,1277 ****
  
                  {
                      Object[] executeData = (Object[])pendingExecuteQueue.get(executeIndex++);
!                     Query currentQuery = (Query)executeData[0];
                      Portal currentPortal = (Portal)executeData[1];
  
!                     if (fields != null || tuples != null)
                      { // There was a resultset.
                          handler.handleResultRows(currentQuery, fields, tuples, null);
                          fields = null;
--- 1315,1335 ----
  
                  {
                      Object[] executeData = (Object[])pendingExecuteQueue.get(executeIndex++);
!                     SimpleQuery currentQuery = (SimpleQuery)executeData[0];
                      Portal currentPortal = (Portal)executeData[1];
+                   
+                     // For the purposes of the below test, we want to know if
+                     // we got anything new, not if we already have the data.  
+                     Field origFields[] = fields;
+ 
+                     // use cached fields if available
+                     if (currentQuery.getFields() != null) {
+                         fields = currentQuery.getFields();
+                     } else {
+                         currentQuery.setFields(origFields);
+                     }
  
!                     if (origFields != null || tuples != null)
                      { // There was a resultset.
                          handler.handleResultRows(currentQuery, fields, tuples, null);
                          fields = null;
***************
*** 1288,1294 ****
                  break;
  
              case 'D':  // Data Transfer (ongoing Execute response)
!                 Object tuple = null;
                  try {
                      tuple = pgStream.ReceiveTupleV3();
                  } catch(OutOfMemoryError oome) {
--- 1346,1352 ----
                  break;
  
              case 'D':  // Data Transfer (ongoing Execute response)
!                 byte[][] tuple = null;
                  try {
                      tuple = pgStream.ReceiveTupleV3();
                  } catch(OutOfMemoryError oome) {
***************
*** 1305,1313 ****
                      tuples.addElement(tuple);
                  }
  
!                 if (logger.logDebug())
!                     logger.debug(" <=BE DataRow");
! 
                  break;
  
              case 'E':  // Error Response (response to pretty much everything; backend then skips until Sync)
--- 1363,1380 ----
                      tuples.addElement(tuple);
                  }
  
!                 if (logger.logDebug()) {
!                     int length;
!                     if (tuple == null) {
!                         length = -1;
!                     } else {
!                         length = 0;
!                         for (int i=0; i< tuple.length; ++i) {
!                             length += tuple[i].length;
!                         }
!                     }
!                     logger.debug(" <=BE DataRow(len=" + length + ")");
!                 }
                  break;
  
              case 'E':  // Error Response (response to pretty much everything; backend then skips until Sync)
***************
*** 1368,1374 ****
                  tuples = new Vector();
                  if (doneAfterRowDescNoData) {
                      Object describeData[] = (Object[])pendingDescribeStatementQueue.get(describeIndex++);
!                     Query currentQuery = (Query)describeData[0];
  
                      if (fields != null || tuples != null)
                      { // There was a resultset.
--- 1435,1442 ----
                  tuples = new Vector();
                  if (doneAfterRowDescNoData) {
                      Object describeData[] = (Object[])pendingDescribeStatementQueue.get(describeIndex++);
!                     SimpleQuery currentQuery = (SimpleQuery)describeData[0];
!                     currentQuery.setFields(fields);
  
                      if (fields != null || tuples != null)
                      { // There was a resultset.
***************
*** 1500,1505 ****
--- 1568,1576 ----
                                    null,  /* name not yet determined */
                                    typeOid, typeLength, typeModifier, tableOid, positionInTable);
              fields[i].setFormat(formatType);
+ 
+             if (logger.logDebug())
+                 logger.debug("        " + fields[i]);
          }
  
          return fields;
diff -rcN -x'*.class' -x'*.jar' -x'*.swp' clean/org/postgresql/core/v3/SimpleQuery.java kris5/org/postgresql/core/v3/SimpleQuery.java
*** clean/org/postgresql/core/v3/SimpleQuery.java	2006-09-11 11:28:40.000000000 -0600
--- kris5/org/postgresql/core/v3/SimpleQuery.java	2006-11-26 02:25:46.000000000 -0700
***************
*** 54,59 ****
--- 54,78 ----
          unprepare();
      }
  
+     /**
+      * Returns the fields that this query will return. If the result set fields
+      * are not known returns null.
+      * 
+      * @return the fields that this query will return.
+      */
+     Field[] getFields() {
+         return fields;
+     }
+ 
+     /**
+      * Sets the fields that this query will return.
+      * 
+      * @param fields The fields that this query will return.
+      */
+     void setFields(Field[] fields) {
+         this.fields = fields;
+     }
+ 
      //
      // V3Query
      //
***************
*** 121,126 ****
--- 140,150 ----
          encodedStatementName = null;
      }
  
+     /**
+      * The stored fields from previous query of a prepared statement,
+      * if executed before. Always null for non-prepared statemsnts.
+      */
+     private Field[] fields;
      private final String[] fragments;
      private String statementName;
      private byte[] encodedStatementName;
diff -rcN -x'*.class' -x'*.jar' -x'*.swp' clean/org/postgresql/Driver.java.in kris5/org/postgresql/Driver.java.in
*** clean/org/postgresql/Driver.java.in	2005-11-23 23:18:28.000000000 -0700
--- kris5/org/postgresql/Driver.java.in	2006-11-26 03:24:36.000000000 -0700
***************
*** 431,436 ****
--- 431,438 ----
                    "When connections that are not explicitly closed are garbage collected, log the stacktrace from the opening of the connection to trace the leak source."},
                  { "prepareThreshold", Boolean.FALSE,
                    "Default statement prepare threshold (numeric)." },
+                 { "binaryEncoding", Boolean.FALSE,
+                   "Receive data in binary format if possible." },
                  { "charSet", Boolean.FALSE,
                    "When connecting to a pre-7.3 server, the database encoding to assume is in use." },
                  { "compatible", Boolean.FALSE,
diff -rcN -x'*.class' -x'*.jar' -x'*.swp' clean/org/postgresql/jdbc2/AbstractJdbc2Connection.java kris5/org/postgresql/jdbc2/AbstractJdbc2Connection.java
*** clean/org/postgresql/jdbc2/AbstractJdbc2Connection.java	2006-11-04 23:23:10.000000000 -0700
--- kris5/org/postgresql/jdbc2/AbstractJdbc2Connection.java	2006-11-26 02:47:21.000000000 -0700
***************
*** 15,21 ****
  import java.util.*;
  import org.postgresql.core.*;
  import org.postgresql.Driver;
- import org.postgresql.PGConnection;
  import org.postgresql.PGNotification;
  import org.postgresql.fastpath.Fastpath;
  import org.postgresql.largeobject.LargeObjectManager;
--- 15,20 ----
***************
*** 117,122 ****
--- 116,130 ----
          {
          }
  
+         boolean binaryEncoding = true;
+         try
+         {
+             binaryEncoding = Boolean.valueOf(info.getProperty("binaryEncoding", "true")).booleanValue();
+         }
+         catch (Exception e)
+         {
+         }
+         
          //Print out the driver version number
          if (logger.logInfo())
              logger.info(Driver.getVersion());
***************
*** 126,136 ****
--- 134,178 ----
          this.dbVersionNumber = protoConnection.getServerVersion();
          this.compatible = info.getProperty("compatible", Driver.MAJORVERSION + "." + Driver.MINORVERSION);
  
+         // Bit set that has a bit set for each oid which should be received
+         // using binary format.
+         BitSet useBinaryForOids = new BitSet();
+         if (binaryEncoding && protoConnection.getProtocolVersion() >= 3) {
+             // currently supported binary encodings
+             useBinaryForOids.set(Oid.BYTEA);
+             useBinaryForOids.set(Oid.TIME);
+             useBinaryForOids.set(Oid.DATE);
+             useBinaryForOids.set(Oid.TIMETZ);
+             useBinaryForOids.set(Oid.TIMESTAMP);
+             useBinaryForOids.set(Oid.TIMESTAMPTZ);
+             useBinaryForOids.set(Oid.INT2);
+             useBinaryForOids.set(Oid.INT4);
+             useBinaryForOids.set(Oid.INT8);
+             useBinaryForOids.set(Oid.FLOAT4);
+             useBinaryForOids.set(Oid.FLOAT8);
+         }        
+         protoConnection.setBinaryOids(useBinaryForOids);
+ 
          if (logger.logDebug())
          {
              logger.debug("    compatible = " + compatible);
              logger.debug("    loglevel = " + logLevel);
              logger.debug("    prepare threshold = " + prepareThreshold);
+             logger.debug("    integer date/time = " + protoConnection.getIntegerDateTimes());
+             StringBuffer sb = new StringBuffer();
+             sb.append(   "    binary encoded types = ");
+             int oid = -1;
+             boolean found = false;
+             while ((oid = useBinaryForOids.nextSetBit(oid + 1)) != -1) {
+                 sb.append(Oid.toString(oid));
+                 sb.append(',');
+                 found = true;
+             }
+             sb.setLength(sb.length() - 1);
+             if (!found) {
+                 sb.append(" <none>");
+             }
+             logger.debug(sb.toString());
          }
  
          //
***************
*** 151,157 ****
          }
  
          // Initialize timestamp stuff
!         timestampUtils = new TimestampUtils(haveMinimumServerVersion("7.4"));
  
          // Initialize common queries.
          commitQuery = getQueryExecutor().createSimpleQuery("COMMIT");
--- 193,200 ----
          }
  
          // Initialize timestamp stuff
!         timestampUtils = new TimestampUtils(haveMinimumServerVersion("7.4"),
!                                !protoConnection.getIntegerDateTimes());
  
          // Initialize common queries.
          commitQuery = getQueryExecutor().createSimpleQuery("COMMIT");
diff -rcN -x'*.class' -x'*.jar' -x'*.swp' clean/org/postgresql/jdbc2/AbstractJdbc2ResultSet.java kris5/org/postgresql/jdbc2/AbstractJdbc2ResultSet.java
*** clean/org/postgresql/jdbc2/AbstractJdbc2ResultSet.java	2006-11-05 22:45:24.000000000 -0700
--- kris5/org/postgresql/jdbc2/AbstractJdbc2ResultSet.java	2006-11-26 01:52:22.000000000 -0700
***************
*** 26,31 ****
--- 26,32 ----
  import java.util.TimeZone;
  import org.postgresql.core.*;
  import org.postgresql.largeobject.*;
+ import org.postgresql.util.ByteConverter;
  import org.postgresql.util.PGobject;
  import org.postgresql.util.PGbytea;
  import org.postgresql.util.PGtokenizer;
***************
*** 387,392 ****
--- 388,414 ----
      public java.sql.Date getDate(int i, java.util.Calendar cal) throws SQLException
      {
          this.checkResultSet(i);
+         
+         int col = i - 1;
+         
+         if (this_row[col] == null) {
+             return null;
+         }
+         
+         if (fields[col].getFormat() == Field.BINARY_FORMAT) {
+             int oid = fields[col].getOID();
+             if (oid == Oid.DATE) {
+                 TimeZone tz = cal == null ? null : cal.getTimeZone();
+                 return connection.getTimestampUtils().toDateBin(tz, this_row[col]);
+             } else if (oid == Oid.TIMESTAMP || oid == Oid.TIMESTAMPTZ) {
+                 // JDBC spec says getDate of Timestamp must be supported
+                 return new Date(getTimestamp(i, cal).getTime());
+             } else {
+                 throw new PSQLException (GT.tr("Cannot convert the column of type {0} to requested type {1}.",
+                         new Object[]{Oid.toString(oid), "date"}),
+                         PSQLState.DATA_TYPE_MISMATCH);
+             }
+         }
  
          if (cal != null)
              cal = (Calendar)cal.clone();
***************
*** 398,403 ****
--- 420,446 ----
      public Time getTime(int i, java.util.Calendar cal) throws SQLException
      {
          this.checkResultSet(i);
+         int col = i - 1;
+         
+         if (this_row[col] == null) {
+             return null;
+         }
+         
+         if (fields[col].getFormat() == Field.BINARY_FORMAT) {
+             int oid = fields[col].getOID();
+             if (oid == Oid.TIME || oid == Oid.TIMETZ) {
+                 TimeZone tz = cal == null ? null : cal.getTimeZone();
+                 return connection.getTimestampUtils().toTimeBin(tz, this_row[col]);
+             } else if (oid == Oid.TIMESTAMP || oid == Oid.TIMESTAMPTZ) {
+                 // JDBC spec says getTime of Timestamp must be supported
+                 Timestamp t = getTimestamp(i, cal);
+                 return new Time(t.getTime());
+             } else {
+                 throw new PSQLException (GT.tr("Cannot convert the column of type {0} to requested type {1}.",
+                         new Object[]{Oid.toString(oid), "time"}),
+                         PSQLState.DATA_TYPE_MISMATCH);
+             }
+         }
  
          if (cal != null)
              cal = (Calendar)cal.clone();
***************
*** 410,415 ****
--- 453,486 ----
      {
          this.checkResultSet(i);
  
+         int col = i - 1;
+         
+         if (this_row[col] == null) {
+             return null;
+         }
+         
+         if (fields[col].getFormat() == Field.BINARY_FORMAT) {
+             int oid = fields[col].getOID();
+             if (oid == Oid.TIMESTAMPTZ || oid == Oid.TIMESTAMP) {
+                 boolean hasTimeZone = oid == Oid.TIMESTAMPTZ;
+                 TimeZone tz = cal == null ? null : cal.getTimeZone();
+                 return connection.getTimestampUtils().toTimestampBin(tz, this_row[col], hasTimeZone);
+             } else {
+                 // JDBC spec says getTimestamp of Time and Date must be supported
+                 long millis;
+                 if (oid == Oid.TIME || oid == Oid.TIMETZ) {
+                     millis = getTime(i, cal).getTime();
+                 } else if (oid == Oid.DATE) {
+                     millis = getDate(i, cal).getTime();
+                 } else {
+                     throw new PSQLException (GT.tr("Cannot convert the column of type {0} to requested type {1}.",
+                             new Object[]{Oid.toString(oid), "timestamp"}),
+                             PSQLState.DATA_TYPE_MISMATCH);
+                 }
+                 return new Timestamp(millis);
+             }
+         }
+ 
          if (cal != null)
              cal = (Calendar)cal.clone();
  
***************
*** 1853,1858 ****
--- 1924,1938 ----
          wasNullFlag = (this_row[columnIndex - 1] == null);
          if (wasNullFlag)
              return null;
+         
+         // convert binary fields to their text format
+         if (fields[columnIndex - 1].getFormat() == Field.BINARY_FORMAT) {
+             Object obj = internalGetObject(columnIndex, fields[columnIndex - 1]);
+             if (obj == null) {
+                 return null;
+             }
+             return trimString(columnIndex, obj.toString());
+         }
  
          Encoding encoding = connection.getEncoding();
          try
***************
*** 1875,1880 ****
--- 1955,1977 ----
  
      public byte getByte(int columnIndex) throws SQLException
      {
+         checkResultSet(columnIndex);
+         
+         int col = columnIndex - 1;
+         
+         wasNullFlag = (this_row[col] == null);
+         if (wasNullFlag) {
+             return 0;
+         }
+         
+         if (fields[col].getFormat() == Field.BINARY_FORMAT) {
+             // there is no Oid for byte so must always do conversion from
+             // some other numeric type
+             return (byte) 
+                 readLongValue(this_row[col], fields[col].getOID(), Byte.MIN_VALUE,
+                               Byte.MAX_VALUE, "byte");
+         }
+ 
          String s = getString(columnIndex);
  
          if (s != null )
***************
*** 1920,1925 ****
--- 2017,2040 ----
  
      public short getShort(int columnIndex) throws SQLException
      {
+         checkResultSet(columnIndex);
+         
+         int col = columnIndex - 1;
+         
+         wasNullFlag = (this_row[col] == null);
+         if (wasNullFlag) {
+             return 0;
+         }
+         
+         if (fields[col].getFormat() == Field.BINARY_FORMAT) {
+             int oid = fields[col].getOID();
+             if (oid == Oid.INT2) {
+                 return ByteConverter.int2(this_row[col], 0);
+             }
+             return (short) readLongValue(this_row[col], oid, Short.MIN_VALUE,
+                                          Short.MAX_VALUE, "short");
+         }
+ 
          String s = getFixedString(columnIndex);
  
          if (s != null)
***************
*** 1958,1963 ****
--- 2073,2096 ----
  
      public int getInt(int columnIndex) throws SQLException
      {
+         checkResultSet(columnIndex);
+ 
+         int col = columnIndex - 1;
+         
+         wasNullFlag = (this_row[col] == null);
+         if (wasNullFlag) {
+             return 0;
+         }
+         
+         if (fields[col].getFormat() == Field.BINARY_FORMAT) {
+             int oid = fields[col].getOID();
+             if (oid == Oid.INT4) {
+                 return ByteConverter.int4(this_row[col], 0);
+             }
+             return (int) readLongValue(this_row[col], oid, Integer.MIN_VALUE,
+                                        Integer.MAX_VALUE, "int");
+         }
+ 
          Encoding encoding = connection.getEncoding();
          if (encoding.hasAsciiNumbers()) {
              try {
***************
*** 1970,1975 ****
--- 2103,2127 ----
  
      public long getLong(int columnIndex) throws SQLException
      {
+         checkResultSet(columnIndex);
+         
+         int col = columnIndex - 1;
+         
+         wasNullFlag = (this_row[col] == null);
+         if (wasNullFlag) {
+             return 0;
+         }
+         
+         if (fields[col].getFormat() == Field.BINARY_FORMAT) {
+             int oid = fields[col].getOID();
+             if (oid == Oid.INT8) {
+                 return ByteConverter.int8(this_row[col], 0);
+             }
+             
+             return readLongValue(this_row[col], oid, Long.MIN_VALUE,
+                                  Long.MAX_VALUE, "long");
+         }
+ 
          Encoding encoding = connection.getEncoding();
          if (encoding.hasAsciiNumbers()) {
              try {
***************
*** 1995,2006 ****
       */
      private long getFastLong(int columnIndex) throws SQLException,
          NumberFormatException {
- 
-         checkResultSet( columnIndex );
          
          columnIndex--;
!         if (this_row[columnIndex] == null) {
!             return 0; // SQL NULL
          }
          
          byte[] bytes = this_row[columnIndex];
--- 2147,2157 ----
       */
      private long getFastLong(int columnIndex) throws SQLException,
          NumberFormatException {
          
          columnIndex--;
!         wasNullFlag = (this_row[columnIndex] == null);
!         if (wasNullFlag) {
!             return 0;
          }
          
          byte[] bytes = this_row[columnIndex];
***************
*** 2054,2064 ****
       * {@link #toLong(String)}.
       */
      private int getFastInt(int columnIndex) throws SQLException {
-         checkResultSet( columnIndex );
-         
          columnIndex--;
!         if (this_row[columnIndex] == null) {
!             return 0; // SQL NULL
          }
          
          byte[] bytes = this_row[columnIndex];
--- 2205,2214 ----
       * {@link #toLong(String)}.
       */
      private int getFastInt(int columnIndex) throws SQLException {
          columnIndex--;
!         wasNullFlag = (this_row[columnIndex] == null);
!         if (wasNullFlag) {
!             return 0;
          }
          
          byte[] bytes = this_row[columnIndex];
***************
*** 2103,2113 ****
--- 2253,2297 ----
  
      public float getFloat(int columnIndex) throws SQLException
      {
+         checkResultSet(columnIndex);
+         
+         int col = columnIndex - 1;
+         
+         wasNullFlag = (this_row[col] == null);
+         if (wasNullFlag) {
+             return 0;
+         }
+         
+         if (fields[col].getFormat() == Field.BINARY_FORMAT) {
+             int oid = fields[col].getOID();
+             if (oid == Oid.FLOAT4) {
+                 return ByteConverter.float4(this_row[col], 0);
+             }
+             return (float) readDoubleValue(this_row[col], oid, "float");
+         }
+ 
          return toFloat( getFixedString(columnIndex) );
      }
  
      public double getDouble(int columnIndex) throws SQLException
      {
+         checkResultSet(columnIndex);
+         
+         int col = columnIndex - 1;
+         
+         wasNullFlag = (this_row[col] == null);
+         if (wasNullFlag) {
+             return 0;
+         }
+         
+         if (fields[col].getFormat() == Field.BINARY_FORMAT) {
+             int oid = fields[col].getOID();
+             if (oid == Oid.FLOAT8) {
+                 return ByteConverter.float8(this_row[col], 0);
+             }
+             return readDoubleValue(this_row[col], oid, "double");
+         }
+ 
          return toDouble( getFixedString(columnIndex) );
      }
  
***************
*** 2806,2811 ****
--- 2990,3082 ----
          else
              updateValues.put(fields[columnIndex - 1].getColumnName(connection), value);
      }
+     
+     /**
+      * Converts any numeric binary field to double value. This method
+      * does no overflow checking.
+      * <p>
+      * This method must is use by getFloat and getDouble.
+      * It must the subset of the following java types that use Binary encoding.
+      * (fields that use text encoding use a different code path for conversion).
+      * <p>
+      * <code>byte,short,int,long,float,double,BigDecimal,boolean,string</code>.
+      * 
+      * @param bytes The bytes of the numeric field.
+      * @param oid The oid of the field.
+      * @param targetType The target type. Used for error reporting.
+      * @return The value as double.
+      * @throws PSQLException If the field type is not supported numeric type.
+      */
+     private double readDoubleValue(byte[] bytes, int oid,
+                                    String targetType) throws PSQLException {
+         // currently implemented binary encoded fields
+         switch (oid) {
+         case Oid.INT2:
+             return ByteConverter.int2(bytes, 0);
+         case Oid.INT4:
+             return ByteConverter.int4(bytes, 0);
+         case Oid.INT8:
+             return ByteConverter.int8(bytes, 0);
+         case Oid.FLOAT4:
+             return ByteConverter.float4(bytes, 0);
+         case Oid.FLOAT8:
+             return ByteConverter.float8(bytes, 0);
+         }
+         throw new PSQLException (GT.tr("Cannot convert the column of type {0} to requested type {1}.",
+                     new Object[]{Oid.toString(oid), targetType}),
+                     PSQLState.DATA_TYPE_MISMATCH); 
+     }
+ 
+     /**
+      * Converts any numeric binary field to long value.
+      * <p>
+      * This method must is use by getByte,getShort,getInt and getLong.
+      * It must the subset of the following java types that use Binary encoding.
+      * (fields that use text encoding use a different code path for conversion).
+      * <p>
+      * <code>byte,short,int,long,float,double,BigDecimal,boolean,string</code>.
+ 
+      * @param bytes The bytes of the numeric field.
+      * @param oid The oid of the field.
+      * @param minVal the minimum value allowed.
+      * @param minVal the maximum value allowed.
+      * @param targetType The target type. Used for error reporting.
+      * @return The value as long.
+      * @throws PSQLException If the field type is not supported numeric type
+      * or if the value is out of range.
+      */
+     private long readLongValue(byte[] bytes, int oid, long minVal, long maxVal,
+                                String targetType)
+         throws PSQLException {
+         long val;
+         // currently implemented binary encoded fields
+         switch (oid) {
+         case Oid.INT2:
+             val = ByteConverter.int2(bytes, 0);
+             break;
+         case Oid.INT4:
+             val = ByteConverter.int4(bytes, 0);
+             break;
+         case Oid.INT8:
+             val = ByteConverter.int8(bytes, 0);
+             break;
+         case Oid.FLOAT4:
+             val = (long) ByteConverter.float4(bytes, 0);
+             break;
+         case Oid.FLOAT8:
+             val = (long) ByteConverter.float8(bytes, 0);
+             break;
+         default:
+             throw new PSQLException (GT.tr("Cannot convert the column of type {0} to requested type {1}.",
+                     new Object[]{Oid.toString(oid), targetType}),
+                     PSQLState.DATA_TYPE_MISMATCH); 
+         }
+         if (val < minVal || val > maxVal) {
+             throw new PSQLException(GT.tr("Bad value for type {0} : {1}", new Object[]{targetType, val}),
+                                     PSQLState.NUMERIC_VALUE_OUT_OF_RANGE);
+         }
+         return val;
+     }
  
      private class PrimaryKey
      {
diff -rcN -x'*.class' -x'*.jar' -x'*.swp' clean/org/postgresql/jdbc2/TimestampUtils.java kris5/org/postgresql/jdbc2/TimestampUtils.java
*** clean/org/postgresql/jdbc2/TimestampUtils.java	2006-04-28 20:33:46.000000000 -0600
--- kris5/org/postgresql/jdbc2/TimestampUtils.java	2006-11-25 23:05:50.000000000 -0700
***************
*** 17,22 ****
--- 17,24 ----
  import java.util.SimpleTimeZone;
  
  import org.postgresql.PGStatement;
+ import org.postgresql.core.Oid;
+ import org.postgresql.util.ByteConverter;
  import org.postgresql.util.GT;
  import org.postgresql.util.PSQLState;
  import org.postgresql.util.PSQLException;
***************
*** 29,42 ****
      private StringBuffer sbuf = new StringBuffer();
  
      private Calendar defaultCal = new GregorianCalendar();
  
      private Calendar calCache;
      private int calCacheZone;
  
      private boolean min74;
  
!     TimestampUtils(boolean min74) {
          this.min74 = min74;
      }
  
      private Calendar getCalendar(int sign, int hr, int min) {
--- 31,51 ----
      private StringBuffer sbuf = new StringBuffer();
  
      private Calendar defaultCal = new GregorianCalendar();
+     private final TimeZone defaultTz = defaultCal.getTimeZone();
  
      private Calendar calCache;
      private int calCacheZone;
  
      private boolean min74;
  
!     /**
!      * True if the backend uses doubles for time values. False if long is used.
!      */
!     private final boolean usesDouble;
! 
!     TimestampUtils(boolean min74, boolean usesDouble) {
          this.min74 = min74;
+         this.usesDouble = usesDouble;
      }
  
      private Calendar getCalendar(int sign, int hr, int min) {
***************
*** 598,601 ****
--- 607,757 ----
          return '\0';
      }
  
+     /**
+      * Returns the SQL Date object matching the given bytes with
+      * {@link Oid#DATE}.
+      * 
+      * @param tz The timezone used.
+      * @param bytes The binary encoded date value.
+      * @return The parsed date object.
+      * @throws PSQLException If binary format could not be parsed.
+      */
+     public Date toDateBin(TimeZone tz, byte[] bytes) throws PSQLException {
+         if (bytes.length != 4) {
+             throw new PSQLException(GT.tr("Unsupported binary encoding of {0}.",
+                     "date"), PSQLState.BAD_DATETIME_FORMAT);
+         }
+         int days = ByteConverter.int4(bytes, 0);
+ 
+         long secs = toJavaSecs(days * 86400L);
+         
+         if (tz == null) {
+             tz = defaultTz;
+         }
+ 
+         return new Date(secs * 1000L - tz.getRawOffset());
+     }
+ 
+     /**
+      * Returns the SQL Time object matching the given bytes with
+      * {@link Oid#TIME} or {@link Oid#TIMETZ}.
+      * 
+      * @param tz The timezone used when received data is {@link Oid#TIME},
+      * ignored if data already contains {@link Oid#TIMETZ}.
+      * @param bytes The binary encoded time value.
+      * @return The parsed time object.
+      * @throws PSQLException If binary format could not be parsed.
+      */
+     public Time toTimeBin(TimeZone tz, byte[] bytes) throws PSQLException {
+         if ((bytes.length != 8 && bytes.length != 12)) {
+             throw new PSQLException(GT.tr("Unsupported binary encoding of {0}.",
+                     "time"), PSQLState.BAD_DATETIME_FORMAT);
+         }
+         
+         long millis;
+         int timeOffset;
+         
+         if (usesDouble) {
+             double time = ByteConverter.float8(bytes, 0);
+             
+             millis = (long) (time * 1000);
+         } else {
+             long time = ByteConverter.int8(bytes, 0);
+ 
+             millis = time / 1000;
+         }
+         
+         if (bytes.length == 12) {
+             timeOffset = ByteConverter.int4(bytes, 8);
+             timeOffset *= -1000;
+         } else {
+             if (tz == null) {
+                 tz = defaultTz;
+             }
+             
+             timeOffset = tz.getRawOffset();
+         }
+ 
+         return new Time(millis - timeOffset);
+     }
+ 
+     /**
+      * Returns the SQL Timestamp object matching the given bytes with
+      * {@link Oid#TIMESTAMP} or {@link Oid#TIMESTAMPTZ}.
+      * 
+      * @param tz The timezone used when received data is {@link Oid#TIMESTAMP},
+      * ignored if data already contains {@link Oid#TIMESTAMPTZ}.
+      * @param bytes The binary encoded timestamp value.
+      * @param timestamptz True if the binary is in GMT.
+      * @return The parsed timestamp object.
+      * @throws PSQLException If binary format could not be parsed.
+      */
+     public Timestamp toTimestampBin(TimeZone tz, byte[] bytes, boolean timestamptz)
+         throws PSQLException {
+         
+         if (bytes.length != 8) {
+             throw new PSQLException(GT.tr("Unsupported binary encoding of {0}.",
+                     "timestamp"), PSQLState.BAD_DATETIME_FORMAT);
+         }
+ 
+         long secs;
+         int nanos;
+         int offset;
+         
+         if (usesDouble) {
+             double time = ByteConverter.float8(bytes, 0);
+ 
+             secs = (long) time;
+             nanos = (int) ((time - secs) * 1000000);
+         } else {
+             long time = ByteConverter.int8(bytes, 0);
+             
+             secs = time / 1000000;
+             nanos = (int) (time - secs * 1000000);
+         }
+         if (nanos < 0) {
+             secs--;
+             nanos += 1000000;
+         }
+         nanos *= 1000;
+         
+         secs = toJavaSecs(secs);
+         if (timestamptz) {
+             offset = 0;
+         } else {
+             if (tz == null) {
+                 tz = defaultTz;
+             }
+             offset = tz.getRawOffset();
+         }
+ 
+         Timestamp ts = new Timestamp(secs * 1000 - offset);
+         ts.setNanos(nanos);
+         return ts;
+     }
+     
+     /**
+      * Converts the given postgresql seconds to java seconds.
+      * Reverse engineered by inserting varying dates to postgresql
+      * and tuning the formula until the java dates matched.
+      * 
+      * @param secs Postgresql seconds.
+      * @return Java seconds.
+      */
+     private long toJavaSecs(long secs) {
+         // postgres epoc to java epoc
+         secs += 946684800L;
+ 
+         // Julian/Greagorian calendar cutoff point
+         if (secs < -12219292800L) { // October 4, 1582 -> October 15, 1582
+             secs += 86400 * 10;
+             if (secs < -14825808000L) { // 1500-02-28 -> 1500-03-01
+                 int extraLeaps = (int) ((secs + 14825808000L) / 3155760000L);
+                 extraLeaps--;
+                 extraLeaps -= extraLeaps / 4;
+                 secs += extraLeaps * 86400L;
+             }
+         }
+         return secs;
+     }
  }
diff -rcN -x'*.class' -x'*.jar' -x'*.swp' clean/org/postgresql/test/jdbc3/ByteaBenchTest.java kris5/org/postgresql/test/jdbc3/ByteaBenchTest.java
*** clean/org/postgresql/test/jdbc3/ByteaBenchTest.java	1969-12-31 17:00:00.000000000 -0700
--- kris5/org/postgresql/test/jdbc3/ByteaBenchTest.java	2006-11-25 23:05:50.000000000 -0700
***************
*** 0 ****
--- 1,197 ----
+ /*-------------------------------------------------------------------------
+ *
+ * Copyright (c) 2004-2005, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ *   $PostgreSQL: pgjdbc/org/postgresql/test/jdbc3/BenchTest.java,v 1.1 2006/07/24 02:31:44 oliver Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+ package org.postgresql.test.jdbc3;
+ 
+ import java.sql.Connection;
+ import java.sql.PreparedStatement;
+ import java.sql.ResultSet;
+ import java.sql.SQLException;
+ import java.sql.Statement;
+ import java.util.Properties;
+ 
+ import junit.framework.TestCase;
+ 
+ import org.postgresql.test.TestUtil;
+ 
+ public class ByteaBenchTest extends TestCase {
+ 
+     /**
+      * Number of times the table is queried.
+      */
+     private static final int QUERY_LOOP = 512;
+ 
+     /**
+      * Number of rows in temporary table.
+      */
+     private static final int[] SIZES = { 512, 2048, 4096, 16384 , 65536, 1048576 };
+ 
+     /**
+      * How many tries long to prime the jit.
+      */
+     private static final int PRIME_LOOP = 2000;
+ 
+     /**
+      * How many times to run the timing and print the times.
+      */
+     private static final int TIMING_LOOP = 10;
+     
+     private Connection _conn;
+ 
+     private String queryString;
+ 
+     private PreparedStatement query;
+     
+     public ByteaBenchTest(String name) {
+         super(name);
+     }
+     
+     protected void setUp() throws Exception {
+         _conn = openDB();
+         _conn.setAutoCommit(false);
+ 
+         createTable();
+ 
+         query = _conn.prepareStatement("SELECT val FROM hold WHERE key=?");
+     }
+     
+     protected Connection openDB() throws Exception {
+         Properties p = new Properties();
+         p.setProperty("prepareThreshold", "1");
+         p.setProperty("binaryEncoding", "true");
+         return TestUtil.openDB(p);
+     }
+ 
+     private void createTable() throws SQLException {
+ 	Statement stmt = _conn.createStatement();
+         stmt.execute("CREATE TEMP TABLE hold(key int, val bytea) " +
+                      " ON COMMIT PRESERVE ROWS");
+         stmt.close();
+ 
+         PreparedStatement insert =
+             _conn.prepareStatement("INSERT INTO hold (key, val) VALUES (?, ?)");
+         
+         StringBuilder sb = new StringBuilder();
+         sb.append("INSERT INTO hold (key");
+         for (int i=0; i<SIZES.length; ++i) {
+             insert.setInt(1, SIZES[i]);
+             insert.setBytes(2, createBytes(SIZES[i]));
+             assertEquals(1, insert.executeUpdate());
+         }
+         insert.close();
+         _conn.commit();
+     }
+ 
+     private byte[] createBytes(int len) {
+         byte[] b = new byte[len];
+         for (int i = 0; i < b.length; ++i) {
+             b[i] = (byte) i;
+         }
+         return b;
+     }
+ 
+     protected void tearDown() throws SQLException {
+ 	query.close();
+         dropTable();
+         TestUtil.closeDB(_conn);
+     }
+ 
+     private void dropTable() {
+ 	Statement stmt;
+ 	try {
+ 	    stmt = _conn.createStatement();
+ 	    stmt.execute("DROP TABLE hold");
+ 	    stmt.close();
+            _conn.commit();
+ 	} catch (SQLException e) {
+ 	    // ignored
+ 	}
+     }
+ 
+     public void testBenchmark() throws Exception {
+         System.out.print("Warming JIT for benchmark loop: ");
+         int printed = -1;
+         for (int i=0; i<PRIME_LOOP; ++i) {
+             for (int s = 0; s < SIZES.length; ++s)
+             query(SIZES[s]);
+             int readyNess = (PRIME_LOOP - i - 1) * 10 / PRIME_LOOP;
+             if (readyNess != printed) {
+                 printed = readyNess;
+                 System.out.print(printed);
+                 clearGC();
+             }
+         }
+         System.out.println();
+         
+         // let jit do it's magic and flush all initial garbage
+         clearGC();
+         Thread.sleep(2000);
+         
+         double[] best = new double[SIZES.length];
+         long[] maxMemUse = new long[SIZES.length];
+         for (int s = 0; s < SIZES.length; ++s) {
+             int size = SIZES[s];
+             long start, stop;
+             int queries = QUERY_LOOP;
+             if (size > 16384) {
+                 queries /= size / 16384;
+             } else {
+                 queries *= 16384 / size;
+             }
+             System.out.printf("Transferring %.1fMB of data in %.1fkb chunks\n",
+                               size * queries / 1024.0 / 1024, size / 1024.0);
+             for (int i=0; i<TIMING_LOOP; ++i) {
+                 start = System.currentTimeMillis();
+                 for (int j=0; j<queries; ++j) {
+                     query(size);
+                 }
+                 stop = System.currentTimeMillis();
+                 _conn.commit();
+ 
+                 Runtime rt = Runtime.getRuntime();
+                 long memUse = rt.totalMemory() - rt.freeMemory();
+                 if (memUse > maxMemUse[s]) {
+                     maxMemUse[s] = memUse;
+                 }
+                 clearGC();
+ 
+                 double speed = queries * 1000.0 / (stop-start) * size;
+                 speed /= 1024 * 1024;
+                 if (speed > best[s]) {
+                     best[s] = speed;
+                 }
+                 System.out.printf(" %7db speed:%5.1fMB/s (best %5.1fMB/s) memory: %5.1fMB (worst %5.1fMB)\n",
+                         size, speed, best[s], memUse/1024.0/1024.0, maxMemUse[s]/1024.0/1024.0);
+             }
+         }
+         
+         for (int s = 0; s < SIZES.length; ++s) {
+             System.out.printf("%7db speed: %5.1fMB/s memory: %5.1fMB\n",
+                     SIZES[s],
+                     best[s], maxMemUse[s]/1024.0/1024.0);
+         }
+     }
+ 
+     private void clearGC() throws InterruptedException {
+         Thread.sleep(10);
+         System.runFinalization();
+         System.gc();
+         Thread.sleep(90);
+     }
+ 
+     private void query(int size) throws SQLException {
+         query.setInt(1, size);
+         ResultSet rs = query.executeQuery();
+         assertTrue(rs.next());
+         byte[] bytes = rs.getBytes(1);
+         assertEquals(size, bytes.length);
+         assertFalse(rs.next());
+         rs.close();
+     }
+ }
diff -rcN -x'*.class' -x'*.jar' -x'*.swp' clean/org/postgresql/test/jdbc3/DateTimeBenchTest.java kris5/org/postgresql/test/jdbc3/DateTimeBenchTest.java
*** clean/org/postgresql/test/jdbc3/DateTimeBenchTest.java	1969-12-31 17:00:00.000000000 -0700
--- kris5/org/postgresql/test/jdbc3/DateTimeBenchTest.java	2006-11-25 23:05:50.000000000 -0700
***************
*** 0 ****
--- 1,392 ----
+ /*-------------------------------------------------------------------------
+ *
+ * Copyright (c) 2004-2005, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ *   $PostgreSQL: pgjdbc/org/postgresql/test/jdbc3/BenchTest.java,v 1.1 2006/07/24 02:31:44 oliver Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+ package org.postgresql.test.jdbc3;
+ 
+ import java.sql.Connection;
+ import java.sql.Date;
+ import java.sql.PreparedStatement;
+ import java.sql.ResultSet;
+ import java.sql.SQLException;
+ import java.sql.Statement;
+ import java.sql.Time;
+ import java.sql.Timestamp;
+ import java.text.ParseException;
+ import java.text.SimpleDateFormat;
+ import java.util.Calendar;
+ import java.util.Locale;
+ import java.util.Properties;
+ import java.util.TimeZone;
+ 
+ import junit.framework.AssertionFailedError;
+ import junit.framework.TestCase;
+ 
+ import org.postgresql.test.TestUtil;
+ 
+ public class DateTimeBenchTest extends TestCase {
+ 
+     private static final TimeZone TZ = TimeZone.getTimeZone("GMT-2");
+ //    private static final TimeZone TZ = TimeZone.getTimeZone("GMT+2");
+ //    private static final TimeZone TZ = TimeZone.getTimeZone("GMT");
+ //    private static final TimeZone TZ = TimeZone.getDefault();
+ 
+     private static final SimpleDateFormat dateFormat;
+     
+     static {
+       dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS", Locale.US);
+       dateFormat.setTimeZone(TZ);
+     }
+     
+     /**
+      * Number of times the table is queried.
+      */
+     private static final int QUERY_LOOP = 100;
+ 
+     private static String[] COLTYPES = {
+         "date",
+ 
+         "time(0) without time zone",
+         "time(6) without time zone",
+         "timestamp(0) without time zone",
+         "timestamp(6) without time zone",
+ 
+         "time(0) with time zone",
+         "time(6) with time zone",
+         "timestamp(0) with time zone",
+         "timestamp(6) with time zone",
+     };
+     
+     private static java.util.Date[] COLVALUES = {
+         get("2006-12-24 00:00:00.000"),
+ 
+         get("1970-01-01 04:58:59.000"),
+         get("1970-01-01 22:17:33.000"),
+         get("2006-11-17 20:17:33.000"),
+         get("1234-05-06 09:12:34.123"),
+         
+         get("1970-01-01 09:12:34.000"),
+         get("1970-01-01 04:59:58.000"),
+         get("2006-11-17 22:17:33.000"),
+         get("2134-05-06 09:12:34.567"),
+     };
+ 
+     /**
+      * Number of columns in each row.
+      */
+     private static final int COLS = COLTYPES.length;
+     
+     /**
+      * Number of rows in temporary table.
+      */
+     private static final int ROWS = 20;
+ 
+     /**
+      * How many tries long to prime the jit.
+      */
+     private static final int PRIME_LOOP = 10000;
+ 
+     /**
+      * How many times to run the timing and print the times.
+      */
+     private static final int TIMING_LOOP = 200;
+     
+     private Connection _conn;
+ 
+     private PreparedStatement insert;
+ 
+     private String queryString;
+ 
+     private PreparedStatement query;
+     
+     public DateTimeBenchTest(String name) {
+         super(name);
+     }
+ 
+     protected void setUp() throws Exception {
+         Properties p = new Properties();
+         p.setProperty("prepareThreshold", "1");
+         p.setProperty("binaryEncoding", "true");
+         _conn = TestUtil.openDB(p);
+ 
+         dropTable();
+         createTable();
+ 
+         _conn.setAutoCommit(false);
+ 
+         StringBuilder sb = new StringBuilder();
+         sb.append("INSERT INTO hold (key");
+         for (int i=0; i<COLS; ++i) {
+             sb.append(", val").append(i);
+         }
+         sb.append(") VALUES (?");
+         for (int i=0; i<COLS; ++i) {
+             sb.append(",?");
+         }
+         sb.append(")");
+ 
+         insert = _conn.prepareStatement(sb.toString());
+ 
+         sb.setLength(0);
+         sb.append("SELECT ");
+         for (int i=0; i<COLS; ++i) {
+             sb.append("val").append(i).append(',');
+         }
+         sb.setLength(sb.length()-1);
+         sb.append(" FROM hold");
+ 
+         query = _conn.prepareStatement(sb.toString());
+     }
+ 
+     private void createTable() throws SQLException {
+ 	StringBuilder sb = new StringBuilder();
+         sb.append("CREATE TABLE hold(key int");
+         for (int i=0; i<COLS; ++i) {
+             sb.append(", val").append(i).append(' ');
+             sb.append(COLTYPES[i]);
+         }
+         sb.append(")");
+ 	Statement stmt = _conn.createStatement();
+         stmt.execute(sb.toString());
+         stmt.close();
+         _conn.commit();
+     }
+ 
+     protected void tearDown() throws SQLException {
+ 	insert.close();
+ 	query.close();
+         dropTable();
+         TestUtil.closeDB(_conn);
+     }
+ 
+     private void dropTable() {
+ 	Statement stmt;
+ 	try {
+ 	    stmt = _conn.createStatement();
+ 	    stmt.execute("DROP TABLE hold");
+ 	    stmt.close();
+            _conn.commit();
+ 	} catch (SQLException e) {
+ 	    // ignored
+ 	}
+     }
+     
+     private void deleteTable() {
+         Statement stmt;
+         try {
+             stmt = _conn.createStatement();
+             stmt.execute("TRUNCATE TABLE hold");
+             stmt.close();
+            _conn.commit();
+         } catch (SQLException e) {
+             // ignored
+         }
+     }
+ 
+     public void testBenchmark() throws Exception {
+         insert();
+         for (int i = 0; i<10; ++i) {
+             try {
+                 assertValues(i+1);
+             } catch (AssertionFailedError e) {
+                 if (i == 0) {
+                     System.out.println("Text based parsing failed");
+                     e.printStackTrace(System.out);
+                 } else {
+                     throw e;
+                 }
+             }
+         }
+         System.out.print("Warming JIT for benchmark loop: ");
+         int printed = -1;
+         for (int i=0; i<PRIME_LOOP; ++i) {
+             query();
+             int readyNess = (PRIME_LOOP - i - 1) * 10 / PRIME_LOOP;
+             if (readyNess != printed) {
+                 printed = readyNess;
+                 System.out.print(printed);
+                 clearGC();
+             }
+         }
+         System.out.println();
+ 
+         // let jit do it's magic and flush all initial garbage
+         clearGC();
+         Thread.sleep(2000);
+         
+         double best = 0;
+         long maxMemUse = 0;
+         long start, stop;
+         Runtime rt = Runtime.getRuntime();
+         for (int i=0; i<TIMING_LOOP; ++i) {
+             start = System.currentTimeMillis();
+             for (int j=0; j<QUERY_LOOP; ++j) {
+         	query();
+             }
+             stop = System.currentTimeMillis();
+ 
+             long memUse = rt.totalMemory() - rt.freeMemory();
+             if (memUse > maxMemUse) {
+                 maxMemUse = memUse;
+             }
+             clearGC();
+             
+             double speed = QUERY_LOOP * 1000.0 / (stop-start);
+             if (speed > best) {
+         	best = speed;
+             }
+             System.out.printf("speed: %7.2f (best %7.2f) memory: %5.1fMB (worst %5.1fMB)\n",
+                     speed, best, memUse/1024.0/1024.0, maxMemUse/1024.0/1024.0);
+         }
+         System.out.printf("speed: %7.2f, memory: %5.1fMB\n", best,
+                 maxMemUse/1024.0/1024.0);
+     }
+ 
+     private void clearGC() throws InterruptedException {
+         Thread.sleep(10);
+         System.runFinalization();
+         System.gc();
+         Thread.sleep(90);
+     }
+ 
+     private void query() throws SQLException {
+         ResultSet rs = query.executeQuery();
+         for (int r=0; r<ROWS; ++r) {
+             assertTrue(rs.next());
+             for (int c=0; c<COLS; ++c) {
+                 switch (c) {
+                 case 3:
+                 case 4:
+                 case 7:
+                 case 8:
+                     Timestamp ts = rs.getTimestamp(c+1);
+                     assertNotNull(ts);
+                     break;
+                 case 0:
+                     Date d = rs.getDate(c+1);
+                     assertNotNull(d);
+                     break;
+                 case 1:
+                 case 2:
+                 case 5:
+                 case 6:
+                     Time t = rs.getTime(c+1);
+                     assertNotNull(t);
+                     break;
+                 }
+             }
+         }
+         rs.close();
+     }
+ 
+     private void insert() throws SQLException {
+         Calendar cal = Calendar.getInstance(TZ, Locale.US);
+ 	for (int r=0; r<ROWS; ++r) {
+ 	    insert.setInt(1, r);
+ 	    for (int c=0; c<COLS; ++c) {
+                 switch (c) {
+                 case 0:
+                     Date d = new Date(COLVALUES[c].getTime());
+                     insert.setDate(c+2, d, cal);
+                     break;
+                 case 3:
+                 case 4:
+                 case 7:
+                 case 8:
+                     Timestamp ts = new Timestamp(COLVALUES[c].getTime());
+                     insert.setTimestamp(c+2, ts, cal);
+                     break;
+                 case 1:
+                 case 2:
+                 case 5:
+                 case 6:
+                     Time t = new Time(COLVALUES[c].getTime());
+                     insert.setTime(c+2, t, cal);
+                     break;
+ 		}
+ 	    }
+ 	    assertFalse(insert.execute());
+ 	    assertTrue(1 == insert.getUpdateCount());
+ 	}
+ 	_conn.commit();
+     }
+     
+     private void testAccepted(int round, int i, java.util.Date time) {
+         long correct = COLVALUES[i].getTime();
+         long tested = time.getTime();
+         testDiff(round, i, correct, tested);
+     }
+ 
+     private void testAcceptedTime(int round, int i, java.util.Date time) {
+         long correct = COLVALUES[i].getTime();
+         long tested = time.getTime();
+         testDiff(round, i, correct % (3600 * 24 * 1000), tested % (3600 * 24 * 1000));
+     }
+ 
+     private void testDiff(int round, int i, long correct, long tested) {
+         long diff = Math.abs(correct - tested);
+         if (diff == 0) {
+             return;
+         }
+         fail("Round " + round + ": Wrong return value for type \"" +
+                 COLTYPES[i] + "\" diff=" + diff);
+     }
+ 
+     private void assertValues(int round) throws SQLException {
+         Calendar cal = Calendar.getInstance(TZ, Locale.US);
+         String r = "R"+round;
+         ResultSet rs = query.executeQuery();
+         assertTrue(rs.next());
+         for (int c=0; c<COLS; ++c) {
+             switch (c) {
+             case 0:
+                 Date d = rs.getDate(c+1, cal);
+                 testAccepted(round, c, d);
+                 testAccepted(round, c, rs.getTimestamp(c+1, cal));
+                 break;
+             case 3:
+             case 4:
+             case 7:
+             case 8:
+                 Timestamp ts = rs.getTimestamp(c+1, cal);
+                 testAccepted(round, c, ts);
+                 testAcceptedTime(round, c, rs.getTime(c+1, cal));
+                 testAccepted(round, c, rs.getDate(c+1, cal));
+                 break;
+             case 1:
+             case 2:
+             case 5:
+             case 6:
+                 Time t = rs.getTime(c+1, cal);
+                 testAccepted(round, c, t);
+                 testAccepted(round, c, rs.getTimestamp(c+1, cal));
+                 break;
+             default:
+                 fail();
+                 return;
+             }
+         }
+         for (int rows = 1; rows<ROWS; ++rows) {
+             assertTrue(rs.next());
+         }
+         rs.close();
+     }
+ 
+     private static String norm(java.util.Date time) {
+         return dateFormat.format(time);
+     }
+ 
+     private static java.util.Date get(String time) {
+         try {
+             return dateFormat.parse(time);
+         } catch (ParseException e) {
+             throw new RuntimeException(e);
+         }
+     }
+ 
+ }
diff -rcN -x'*.class' -x'*.jar' -x'*.swp' clean/org/postgresql/test/jdbc3/NumberBenchTest.java kris5/org/postgresql/test/jdbc3/NumberBenchTest.java
*** clean/org/postgresql/test/jdbc3/NumberBenchTest.java	1969-12-31 17:00:00.000000000 -0700
--- kris5/org/postgresql/test/jdbc3/NumberBenchTest.java	2006-11-25 23:05:50.000000000 -0700
***************
*** 0 ****
--- 1,266 ----
+ /*-------------------------------------------------------------------------
+ *
+ * Copyright (c) 2004-2005, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ *   $PostgreSQL: pgjdbc/org/postgresql/test/jdbc3/BenchTest.java,v 1.1 2006/07/24 02:31:44 oliver Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+ package org.postgresql.test.jdbc3;
+ 
+ import java.sql.Connection;
+ import java.sql.PreparedStatement;
+ import java.sql.ResultSet;
+ import java.sql.SQLException;
+ import java.sql.Statement;
+ import java.util.Properties;
+ 
+ import junit.framework.TestCase;
+ 
+ import org.postgresql.test.TestUtil;
+ 
+ public class NumberBenchTest extends TestCase {
+ 
+     /**
+      * Number of times the table is queried.
+      */
+     private static final int QUERY_LOOP = 500;
+ 
+     private static String[] TYPES = {
+         "int2", "int4", "int8", "real", "double precision",
+         "int2", "int4", "int8", "real", "double precision",
+     };
+ 
+     private static Object[] VALUES = {
+         (short) 30000, 1073741824, -1152921504606846976L, 1234.56f, -0.000123456789,
+         (short) 42, 5, 10L, 0.35f, 35.0,
+     };
+ 
+     /**
+      * Number of columns in each row.
+      */
+     private static final int COLS = TYPES.length;
+ 
+     /**
+      * Number of rows in temporary table.
+      */
+     private static final int ROWS = 20;
+ 
+     /**
+      * How many tries long to prime the jit.
+      */
+     private static final int PRIME_LOOP = 25000;
+ 
+     /**
+      * How many times to run the timing and print the times.
+      */
+     private static final int TIMING_LOOP = 50;
+     
+     private Connection _conn;
+ 
+     private PreparedStatement insert;
+ 
+     private String queryString;
+ 
+     private PreparedStatement query;
+ 
+     public NumberBenchTest(String name) {
+         super(name);
+     }
+ 
+     protected void setUp() throws Exception {
+         Properties p = new Properties();
+         p.setProperty("prepareThreshold", "1");
+         p.setProperty("binaryEncoding", "true");
+         _conn = TestUtil.openDB(p);
+         createTable();
+ 
+         _conn.setAutoCommit(false);
+ 
+         StringBuilder sb = new StringBuilder();
+         sb.append("INSERT INTO hold (key");
+         for (int i=0; i<COLS; ++i) {
+             sb.append(", val").append(i);
+         }
+         sb.append(") VALUES (?");
+         for (int i=0; i<COLS; ++i) {
+             sb.append(",?");
+         }
+         sb.append(")");
+ 
+         insert = _conn.prepareStatement(sb.toString());
+ 
+         insert();
+         
+         sb.setLength(0);
+         sb.append("SELECT ");
+         for (int i=0; i<COLS; ++i) {
+             sb.append("hold.val").append(i).append(',');
+         }
+         sb.setLength(sb.length()-1);
+         sb.append(" FROM hold");
+ 
+         query = _conn.prepareStatement(sb.toString());
+     }
+ 
+     private void createTable() throws SQLException {
+ 	StringBuilder sb = new StringBuilder();
+         sb.append("CREATE TEMP TABLE hold(key int");
+         for (int i=0; i<COLS; ++i) {
+             sb.append(", val").append(i);
+             sb.append(" ").append(TYPES[i]);
+         }
+         sb.append(") ON COMMIT PRESERVE ROWS");
+ 	Statement stmt = _conn.createStatement();
+         stmt.execute(sb.toString());
+         stmt.close();
+         _conn.commit();
+     }
+ 
+     protected void tearDown() throws SQLException {
+ 	insert.close();
+ 	query.close();
+         dropTable();
+         TestUtil.closeDB(_conn);
+     }
+ 
+     private void dropTable() {
+ 	Statement stmt;
+ 	try {
+ 	    stmt = _conn.createStatement();
+ 	    stmt.execute("DROP TABLE hold");
+ 	    stmt.close();
+            _conn.commit();
+ 	} catch (SQLException e) {
+ 	    // ignored
+ 	}
+     }
+ 
+     public void testBenchmark() throws Exception {
+         insert();
+         
+         for (int i=0; i<10; ++i) {
+             assertValues();
+         }
+         
+         System.out.print("Warming JIT for benchmark loop: ");
+         int printed = -1;
+         for (int i=0; i<PRIME_LOOP; ++i) {
+             query();
+             int readyNess = (PRIME_LOOP - i - 1) * 10 / PRIME_LOOP;
+             if (readyNess != printed) {
+                 printed = readyNess;
+                 System.out.print(printed);
+             }
+         }
+         System.out.println();
+   
+         // let jit do it's magic and flush all initial garbage
+         clearGC();
+         Thread.sleep(2000);
+         
+         double best = 0;
+         long maxMemUse = 0;
+         long start, stop;
+         for (int i=0; i<TIMING_LOOP; ++i) {
+             start = System.currentTimeMillis();
+             for (int j=0; j<QUERY_LOOP; ++j) {
+         	query();
+             }
+             stop = System.currentTimeMillis();
+ 
+             Runtime rt = Runtime.getRuntime();
+             long memUse = rt.totalMemory() - rt.freeMemory();
+             if (memUse > maxMemUse) {
+                 maxMemUse = memUse;
+             }
+             clearGC();
+             
+             double speed = QUERY_LOOP * 1000.0 / (stop-start);
+             if (speed > best) {
+         	best = speed;
+             }
+             System.out.printf("speed: %7.2f (best %7.2f) memory: %5.1fMB (worst %5.1fMB)\n",
+                     speed, best, memUse/1024.0/1024.0, maxMemUse/1024.0/1024.0);
+         }
+         System.out.printf("speed: %7.2f, memory: %5.1fMB\n", best,
+                           maxMemUse/1024.0/1024.0);
+     }
+ 
+     private void clearGC() throws InterruptedException {
+         Thread.sleep(10);
+         System.runFinalization();
+         System.gc();
+         Thread.sleep(90);
+     }
+ 
+     private void query() throws SQLException {
+         ResultSet rs = query.executeQuery();
+         for (int r=0; r<ROWS; ++r) {
+             assertTrue(rs.next());
+             for (int c=0; c<COLS; ++c) {
+                 switch (c % 5) {
+                 case 0:
+                     rs.getShort(c+1);
+                     break;
+                 case 1:
+                     rs.getInt(c+1);
+                     break;
+                 case 2:
+                     rs.getLong(c+1);
+                     break;
+                 case 3:
+                     rs.getFloat(c+1);
+                     break;
+                 case 4:
+                     rs.getDouble(c+1);
+                     break;
+                 }
+             }
+         }
+         rs.close();
+     }
+ 
+     private void assertValues() throws SQLException {
+         ResultSet rs = query.executeQuery();
+         assertTrue(rs.next());
+         for (int c=0; c<COLS; ++c) {
+             assertEquals(TYPES[c] + ":" + VALUES[c], VALUES[c].toString(), rs.getObject(c+1).toString());
+             switch (c % 5) {
+             case 0:
+                 assertEquals(VALUES[c], rs.getShort(c+1));
+                 assertEquals(VALUES[c], (short) rs.getInt(c+1));
+                 assertEquals(VALUES[c], (short) rs.getLong(c+1));
+                 break;
+             case 1:
+                 assertEquals(VALUES[c], rs.getInt(c+1));
+                 assertEquals(VALUES[c], (int) rs.getLong(c+1));
+                 break;
+             case 2:
+                 assertEquals(VALUES[c], rs.getLong(c+1));
+                 break;
+             case 3:
+                 assertEquals(VALUES[c], rs.getFloat(c+1));
+                 assertEquals(VALUES[c], (float) rs.getDouble(c+1));
+                 break;
+             case 4:
+                 assertEquals(VALUES[c], rs.getDouble(c+1));
+                 break;
+             }
+         }
+         rs.close();
+     }
+ 
+     private void insert() throws SQLException {
+ 	for (int r=0; r<ROWS; ++r) {
+ 	    insert.setInt(1, r);
+ 	    for (int c=0; c<COLS; ++c) {
+ 	        insert.setObject(c+2, VALUES[c]);
+ 	    }
+ 	    assertFalse(insert.execute());
+ 	    assertTrue(1 == insert.getUpdateCount());
+ 	}
+ 	_conn.commit();
+     }
+ }
diff -rcN -x'*.class' -x'*.jar' -x'*.swp' clean/org/postgresql/test/TestUtil.java kris5/org/postgresql/test/TestUtil.java
*** clean/org/postgresql/test/TestUtil.java	2006-05-15 03:35:57.000000000 -0600
--- kris5/org/postgresql/test/TestUtil.java	2006-11-26 03:04:55.000000000 -0700
***************
*** 35,40 ****
--- 35,41 ----
                                  + getDatabase() 
                                  + "?prepareThreshold=" + getPrepareThreshold()
                                  + "&loglevel=" + getLogLevel()
+                                 + "&binaryEncoding=" + getBinaryEncoding()
                                  + protocolVersion;
      }
  
***************
*** 67,72 ****
--- 68,78 ----
          return Integer.parseInt(System.getProperty("protocolVersion"));
      }
  
+     public static boolean getBinaryEncoding()
+     {
+         return Boolean.getBoolean("binaryEncoding");
+     }
+ 
      /*
       * Returns the Test database
       */
diff -rcN -x'*.class' -x'*.jar' -x'*.swp' clean/org/postgresql/util/ByteConverter.java kris5/org/postgresql/util/ByteConverter.java
*** clean/org/postgresql/util/ByteConverter.java	1969-12-31 17:00:00.000000000 -0700
--- kris5/org/postgresql/util/ByteConverter.java	2006-11-25 23:05:50.000000000 -0700
***************
*** 0 ****
--- 1,92 ----
+ /*-------------------------------------------------------------------------
+  *
+  * Copyright (c) 2006, PostgreSQL Global Development Group
+  *
+  * IDENTIFICATION
+  *   $PostgreSQL: pgjdbc/org/postgresql/util/ByteConverter.java,v 1.1 2006/10/30 18:30:16 jurka Exp $
+  *
+  *-------------------------------------------------------------------------
+  */
+ package org.postgresql.util;
+ 
+ /**
+  * Helper methods to parse java base types from byte arrays. 
+  * 
+  * @author Mikko Tiihonen
+  */
+ public class ByteConverter {
+ 
+     private ByteConverter() {
+         // prevent instantiation of static helper class
+     }
+     
+     /**
+      * Parses a long value from the byte array.
+      * 
+      * @param bytes The byte array to parse.
+      * @param idx The starting index of the parse in the byte array.
+      * @return parsed long value.
+      */
+     public static long int8(byte[] bytes, int idx) {
+         return 
+             ((long)(bytes[idx+0] & 255) << 56) +
+             ((long)(bytes[idx+1] & 255) << 48) +
+             ((long)(bytes[idx+2] & 255) << 40) +
+             ((long)(bytes[idx+3] & 255) << 32) +
+             ((long)(bytes[idx+4] & 255) << 24) +
+             ((long)(bytes[idx+5] & 255) << 16) +
+             ((long)(bytes[idx+6] & 255) <<  8) +
+             ((long)(bytes[idx+7] & 255)      );
+     }
+ 
+     /**
+      * Parses an int value from the byte array.
+      * 
+      * @param bytes The byte array to parse.
+      * @param idx The starting index of the parse in the byte array.
+      * @return parsed int value.
+      */
+     public static int int4(byte[] bytes, int idx) {
+         return 
+             ((bytes[idx  ] & 255) << 24) +
+             ((bytes[idx+1] & 255) << 16) +
+             ((bytes[idx+2] & 255) <<  8) +
+             ((bytes[idx+3] & 255)      );
+     }
+ 
+     /**
+      * Parses a short value from the byte array.
+      * 
+      * @param bytes The byte array to parse.
+      * @param idx The starting index of the parse in the byte array.
+      * @return parsed short value.
+      */
+     public static short int2(byte[] bytes, int idx) {
+         return (short)
+             (((bytes[idx  ] & 255) <<  8) +
+              ((bytes[idx+1] & 255)      ));
+     }
+ 
+     /**
+      * Parses a float value from the byte array.
+      * 
+      * @param bytes The byte array to parse.
+      * @param idx The starting index of the parse in the byte array.
+      * @return parsed float value.
+      */
+     public static float float4(byte[] bytes, int idx) {
+         return Float.intBitsToFloat(int4(bytes, idx));
+     }
+ 
+     /**
+      * Parses a double value from the byte array.
+      * 
+      * @param bytes The byte array to parse.
+      * @param idx The starting index of the parse in the byte array.
+      * @return parsed double value.
+      */
+     public static double float8(byte[] bytes, int idx) {
+         return Double.longBitsToDouble(int8(bytes, idx));
+     }
+ 
+ }