Merge lp:~jim-cirrusql/stado/spatial into lp:stado

[Jim Mlodgenski]

Spatial support

=== added file '.classpath'
--- .classpath	1970-01-01 00:00:00 +0000
+++ .classpath	2011-08-30 20:30:24 +0000
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="lib" path="lib/javacc.jar"/>
+	<classpathentry kind="lib" path="lib/jline-0_9_5.jar"/>
+	<classpathentry kind="lib" path="lib/jtb.jar"/>
+	<classpathentry kind="lib" path="lib/log4j.jar"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

=== added file '.project'
--- .project	1970-01-01 00:00:00 +0000
+++ .project	2011-08-30 20:30:24 +0000
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>stado</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

=== added directory 'bin'
=== modified file 'build.xml'
--- build.xml	2011-05-01 15:49:41 +0000
+++ build.xml	2011-08-30 20:30:24 +0000
@@ -20,8 +20,10 @@
   <property name="builddir" value="build" />
   <property name="distdir" value="dist" />
   <property name="package" value="org/postgresql/stado" />
+  <property name="driver" value="org/postgresql/driver" />
   <property name="packdir" value="${srcdir}/${package}" />
-  <property name="version" value="2_0_beta" />
+  <property name="driverdir" value="${srcdir}/${driver}" />
+  <property name="version" value="2_5_beta" />
 
   <target name="clean">
     <delete quiet="true" dir="${builddir}" />
@@ -45,16 +47,31 @@
     <jar jarfile="${jardir}/stado.jar">
       <fileset dir="${builddir}">
         <include name="${package}/**/*.class" />
+        <include name="${driver}/**/*.class" />
       </fileset>
     </jar>
   </target>
 
   <target name="compile" depends="prepare">
+    <javac srcdir="${driverdir}" destdir="${builddir}" source="1.6" includeAntRuntime="false">
+       <classpath>
+         <pathelement path="${builddir}" />
+       </classpath>
+
+       <include name="*.java" />
+       <include name="copy/**" />
+       <include name="core/**" />
+       <include name="ds/**" />
+       <include name="jdbc2/**" />
+       <include name="jdbc3/**" />
+       <include name="ssl/**" />
+       <include name="util/**" />
+    </javac>
+
     <javac srcdir="${packdir}" destdir="${builddir}" source="1.6" includeAntRuntime="false">
        <classpath>
          <pathelement location="${libdir}/log4j.jar" />
          <pathelement location="${libdir}/jline-0_9_5.jar" />
-         <pathelement location="${libdir}/postgresql.jar" />
          <pathelement path="${builddir}" />
        </classpath>
 
@@ -96,11 +113,9 @@
     <copy file="${jardir}/stado.jar" todir="${distdir}/stado/lib"/>
     <copy file="${libdir}/jline-0_9_5.jar" todir="${distdir}/stado/lib"/>
     <copy file="${libdir}/log4j.jar" todir="${distdir}/stado/lib"/>
-    <copy file="${libdir}/postgresql.jar" todir="${distdir}/stado/lib"/>
-
+    
     <copy file="${libdir}/jline_license.txt" todir="${distdir}/stado/license"/>
     <copy file="${libdir}/log4j_license.txt" todir="${distdir}/stado/license"/>
-    <copy file="${libdir}/postgresql_license.txt" todir="${distdir}/stado/license"/>
     <copy file="misc/license.txt" todir="${distdir}/stado/license"/>
 
     <copy file="${srcdir}/config/server/stado.config" todir="${distdir}/stado/config"/>

=== modified file 'docs/stado_admin_guide.xml'
--- docs/stado_admin_guide.xml	2011-05-01 15:49:41 +0000
+++ docs/stado_admin_guide.xml	2011-08-30 20:30:24 +0000
@@ -1532,7 +1532,7 @@
                <para>xdb.metadata.jdbcdriver</para>
             </entry>
             <entry>
-               <para>org.postgresql.Driver</para>
+               <para>org.postgresql.driver.Driver</para>
             </entry>
             <entry>
                <para>The class name of the JDBC Driver to use with underlying metadata database</para>
@@ -1635,7 +1635,7 @@
                <para>xdb.default.jdbcdriver</para>
             </entry>
             <entry>
-               <para>org.postgresql.Driver</para>
+               <para>org.postgresql.driver.Driver</para>
             </entry>
             <entry>
                <para>The default driver name to use for all connections</para>
@@ -4488,7 +4488,7 @@
 
 create table xsyscolumns
 (
- colid int not null,
+ colid serial,
  tableid int not null,
  colseq smallint not null,
  colname varchar(255) not null,

=== modified file 'docs/stado_loader.xml'
--- docs/stado_loader.xml	2011-05-01 15:49:41 +0000
+++ docs/stado_loader.xml	2011-08-30 20:30:24 +0000
@@ -848,7 +848,7 @@
             <entry>
                <para>
                  The driver class name, if exporting from other databases, 
-                 for example, like: org.postgresql.Driver.
+                 for example, like: org.postgresql.driver.Driver.
                </para>
             </entry>
          </row>
@@ -951,7 +951,7 @@
        <programlisting>
          <![CDATA[
          EXTRACT=select * from atable
-         DRIVERCLASS=org.postgresql.Driver
+         DRIVERCLASS=org.postgresql.driver.Driver
          JDBC_URL=jdbc:postgresql://localhost/mydb?user=myuser&password=mypassword
          OUTFILE=/tmp/atable.txt
         ]]>

=== modified file 'docs/stado_sql_reference.xml'
--- docs/stado_sql_reference.xml	2011-05-01 15:49:41 +0000
+++ docs/stado_sql_reference.xml	2011-08-30 20:30:24 +0000
@@ -1090,10 +1090,6 @@
 
    <para>Returns current date and time (at the start of current statement).</para>
 
-   <para><emphasis role="bold">SYSDATE</emphasis></para>
-
-   <para>Returns current date and time.</para>
-
    <para><emphasis role="bold">TIMEOFDAY()</emphasis></para>
 
    <para>Returns the current date and time as a timestamp.</para>
@@ -1155,12 +1151,6 @@
    <para><emphasis role="bold">MD5(string)</emphasis></para>
    <para>Calculates the MD5 hash of string, returning the result in hexadecimal.</para>
 
-   <para><emphasis role="bold">NVL(expr1, expr2)</emphasis></para>
-   <para>If expr1 is not null, then nvl returns expr2.</para>
-
-   <para><emphasis role="bold">NVL2(expr1,expr2,expr3)</emphasis></para>
-   <para>Returns expr3 if expr1 is null, otherwise returns expr2.</para>
-
    <para><emphasis role="bold">OCTET_LENGTH(s)</emphasis></para>
    <para>Returns the number of bytes in the string</para>
 

=== removed file 'lib/postgresql.jar'
Binary files lib/postgresql.jar	2011-05-01 15:49:41 +0000 and lib/postgresql.jar	1970-01-01 00:00:00 +0000 differ
=== removed file 'lib/postgresql_license.txt'
--- lib/postgresql_license.txt	2011-05-01 15:49:41 +0000
+++ lib/postgresql_license.txt	1970-01-01 00:00:00 +0000
@@ -1,26 +0,0 @@
-Copyright (c) 1997-2008, PostgreSQL Global Development Group
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice,
-   this list of conditions and the following disclaimer.
-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. Neither the name of the PostgreSQL Global Development Group nor the names
-   of its contributors may be used to endorse or promote products derived
-   from this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS 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 THE COPYRIGHT OWNER OR 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.

=== added directory 'src/org/postgresql/driver'
=== added file 'src/org/postgresql/driver/Driver.java'
--- src/org/postgresql/driver/Driver.java	1970-01-01 00:00:00 +0000
+++ src/org/postgresql/driver/Driver.java	2011-08-30 20:30:24 +0000
@@ -0,0 +1,792 @@
+/*****************************************************************************
+ * Copyright (C) 2008 EnterpriseDB Corporation.
+ * Copyright (C) 2011 Stado Global Development Group.
+ *
+ * This file is part of Stado.
+ *
+ * Stado is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Stado is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Stado.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * You can find Stado at http://www.stado.us
+ *
+ ****************************************************************************/
+package org.postgresql.driver;
+
+import java.io.*;
+import java.sql.*;
+import java.util.*;
+import java.net.URL;
+
+import java.security.AccessController;
+import java.security.PrivilegedActionException;
+import java.security.PrivilegedExceptionAction;
+
+
+import org.postgresql.driver.core.Logger;
+import org.postgresql.driver.util.GT;
+import org.postgresql.driver.util.PSQLDriverVersion;
+import org.postgresql.driver.util.PSQLException;
+import org.postgresql.driver.util.PSQLState;
+
+/**
+ * The Java SQL framework allows for multiple database drivers.  Each
+ * driver should supply a class that implements the Driver interface
+ *
+ * <p>The DriverManager will try to load as many drivers as it can find and
+ * then for any given connection request, it will ask each driver in turn
+ * to try to connect to the target URL.
+ *
+ * <p>It is strongly recommended that each Driver class should be small and
+ * standalone so that the Driver class can be loaded and queried without
+ * bringing in vast quantities of supporting code.
+ *
+ * <p>When a Driver class is loaded, it should create an instance of itself
+ * and register it with the DriverManager. This means that a user can load
+ * and register a driver by doing Class.forName("foo.bah.Driver")
+ *
+ * @see org.postgresql.driver.PGConnection
+ * @see java.sql.Driver
+ */
+public class Driver implements java.sql.Driver
+{
+
+    // make these public so they can be used in setLogLevel below
+
+    public static final int DEBUG = 2;
+    public static final int INFO = 1;
+
+    private static final Logger logger = new Logger();
+    private static boolean logLevelSet = false;
+
+    static
+    {
+        try
+        {
+            // moved the registerDriver from the constructor to here
+            // because some clients call the driver themselves (I know, as
+            // my early jdbc work did - and that was based on other examples).
+            // Placing it here, means that the driver is registered once only.
+            java.sql.DriverManager.registerDriver(new Driver());
+        }
+        catch (SQLException e)
+        {
+            e.printStackTrace();
+        }
+    }
+
+    // Helper to retrieve default properties from classloader resource
+    // properties files.
+    private Properties defaultProperties;
+    private synchronized Properties getDefaultProperties() throws IOException {
+        if (defaultProperties != null)
+            return defaultProperties;
+
+        // Make sure we load properties with the maximum possible
+        // privileges.
+        try
+        {
+            defaultProperties = (Properties)
+                AccessController.doPrivileged(new PrivilegedExceptionAction() {
+                        public Object run() throws IOException {
+                            return loadDefaultProperties();
+                        }
+                    });
+        }
+        catch (PrivilegedActionException e)
+        {
+            throw (IOException)e.getException();
+        }
+
+        // Use the loglevel from the default properties (if any)
+        // as the driver-wide default unless someone explicitly called
+        // setLogLevel() already.
+        synchronized (Driver.class) {
+            if (!logLevelSet) {
+                String driverLogLevel = defaultProperties.getProperty("loglevel");
+                if (driverLogLevel != null) {
+                    try {
+                        setLogLevel(Integer.parseInt(driverLogLevel));
+                    } catch (Exception l_e) {
+                        // XXX revisit
+                        // invalid value for loglevel; ignore it
+                    }
+                }
+            }
+        }
+
+        return defaultProperties;
+    }
+
+    private Properties loadDefaultProperties() throws IOException {
+        Properties merged = new Properties();
+
+        try {
+            merged.setProperty("user", System.getProperty("user.name"));
+        } catch (java.lang.SecurityException se) {
+            // We're just trying to set a default, so if we can't
+            // it's not a big deal.
+        }
+
+        // If we are loaded by the bootstrap classloader, getClassLoader()
+        // may return null. In that case, try to fall back to the system
+        // classloader.
+        //
+        // We should not need to catch SecurityException here as we are
+        // accessing either our own classloader, or the system classloader
+        // when our classloader is null. The ClassLoader javadoc claims
+        // neither case can throw SecurityException.
+        ClassLoader cl = getClass().getClassLoader();
+        if (cl == null)
+            cl = ClassLoader.getSystemClassLoader();
+
+        if (cl == null) {
+            logger.debug("Can't find a classloader for the Driver; not loading driver configuration");
+            return merged; // Give up on finding defaults.
+        }
+
+        logger.debug("Loading driver configuration via classloader " + cl);
+
+        // When loading the driver config files we don't want settings found
+        // in later files in the classpath to override settings specified in
+        // earlier files.  To do this we've got to read the returned
+        // Enumeration into temporary storage.
+        ArrayList urls = new ArrayList();
+        Enumeration urlEnum = cl.getResources("org/postgresql/driverconfig.properties");
+        while (urlEnum.hasMoreElements())
+        {
+            urls.add(urlEnum.nextElement());
+        }
+
+        for (int i=urls.size()-1; i>=0; i--) {
+            URL url = (URL)urls.get(i);
+            logger.debug("Loading driver configuration from: " + url);
+            InputStream is = url.openStream();
+            merged.load(is);
+            is.close();
+        }
+
+        return merged;
+    }
+
+    /**
+     * Try to make a database connection to the given URL. The driver
+     * should return "null" if it realizes it is the wrong kind of
+     * driver to connect to the given URL. This will be common, as
+     * when the JDBC driverManager is asked to connect to a given URL,
+     * it passes the URL to each loaded driver in turn.
+     *
+     * <p>The driver should raise an SQLException if it is the right driver
+     * to connect to the given URL, but has trouble connecting to the
+     * database.
+     *
+     * <p>The java.util.Properties argument can be used to pass arbitrary
+     * string tag/value pairs as connection arguments.
+     *
+     * user - (required) The user to connect as
+     * password - (optional) The password for the user
+     * ssl - (optional) Use SSL when connecting to the server
+     * charSet - (optional) The character set to be used for converting
+     *  to/from the database to unicode.  If multibyte is enabled on the
+     *  server then the character set of the database is used as the default,
+     *  otherwise the jvm character encoding is used as the default.
+     *   This value is only used when connecting to a 7.2 or older server.
+     * loglevel - (optional) Enable logging of messages from the driver.
+     *  The value is an integer from 1 to 2 where:
+     *    INFO = 1, DEBUG = 2
+     *  The output is sent to DriverManager.getPrintWriter() if set,
+     *  otherwise it is sent to System.out.
+     * compatible - (optional) This is used to toggle
+     *  between different functionality as it changes across different releases
+     *  of the jdbc driver code.  The values here are versions of the jdbc
+     *  client and not server versions.  For example in 7.1 get/setBytes
+     *  worked on LargeObject values, in 7.2 these methods were changed
+     *  to work on bytea values.  This change in functionality could
+     *  be disabled by setting the compatible level to be "7.1", in
+     *  which case the driver will revert to the 7.1 functionality.
+     *
+     * <p>Normally, at least
+     * "user" and "password" properties should be included in the
+     * properties. For a list of supported
+     * character encoding , see
+     * http://java.sun.com/products/jdk/1.2/docs/guide/internat/encoding.doc.html
+     * Note that you will probably want to have set up the Postgres database
+     * itself to use the same encoding, with the "-E <encoding>" argument
+     * to createdb.
+     *
+     * Our protocol takes the forms:
+     * <PRE>
+     * jdbc:postgresql://host:port/database?param1=val1&...
+     * </PRE>
+     *
+     * @param url the URL of the database to connect to
+     * @param info a list of arbitrary tag/value pairs as connection
+     * arguments
+     * @return a connection to the URL or null if it isnt us
+     * @exception SQLException if a database access error occurs
+     * @see java.sql.Driver#connect
+     */
+    public java.sql.Connection connect(String url, Properties info) throws SQLException
+    {
+        // get defaults
+        Properties defaults;
+        try
+        {
+            defaults = getDefaultProperties();
+        }
+        catch (IOException ioe)
+        {
+            throw new PSQLException(GT.tr("Error loading default settings from driverconfig.properties"),
+                                    PSQLState.UNEXPECTED_ERROR, ioe);
+        }
+
+        // override defaults with provided properties
+        Properties props = new Properties(defaults);
+        for (Enumeration e = info.propertyNames(); e.hasMoreElements(); )
+        {
+            String propName = (String)e.nextElement();
+            props.setProperty(propName, info.getProperty(propName));
+        }
+
+        // parse URL and add more properties
+        if ((props = parseURL(url, props)) == null)
+        {
+            logger.debug("Error in url: " + url);
+            return null;
+        }
+        try
+        {
+            logger.debug("Connecting with URL: " + url);
+
+            // Enforce login timeout, if specified, by running the connection
+            // attempt in a separate thread. If we hit the timeout without the
+            // connection completing, we abandon the connection attempt in
+            // the calling thread, but the separate thread will keep trying.
+            // Eventually, the separate thread will either fail or complete
+            // the connection; at that point we clean up the connection if
+            // we managed to establish one after all. See ConnectThread for
+            // more details.
+            long timeout = timeout(props);
+            if (timeout <= 0)
+                return makeConnection(url, props);
+
+            ConnectThread ct = new ConnectThread(url, props);
+            new Thread(ct, "PostgreSQL JDBC driver connection thread").start();
+            return ct.getResult(timeout);
+        }
+        catch (PSQLException ex1)
+        {
+            logger.debug("Connection error:", ex1);
+            // re-throw the exception, otherwise it will be caught next, and a
+            // org.postgresql.unusual error will be returned instead.
+            throw ex1;
+        }
+        catch (java.security.AccessControlException ace)
+        {
+            throw new PSQLException(GT.tr("Your security policy has prevented the connection from being attempted.  You probably need to grant the connect java.net.SocketPermission to the database server host and port that you wish to connect to."), PSQLState.UNEXPECTED_ERROR, ace);
+        }
+        catch (Exception ex2)
+        {
+            logger.debug("Unexpected connection error:", ex2);
+            throw new PSQLException(GT.tr("Something unusual has occured to cause the driver to fail. Please report this exception."),
+                                    PSQLState.UNEXPECTED_ERROR, ex2);
+        }
+    }
+
+    /**
+     * Perform a connect in a separate thread; supports
+     * getting the results from the original thread while enforcing
+     * a login timout.
+     */
+    private static class ConnectThread implements Runnable {
+        ConnectThread(String url, Properties props) {
+            this.url = url;
+            this.props = props;
+        }
+
+        public void run() {
+            Connection conn;
+            Throwable error;
+
+            try {
+                conn = makeConnection(url, props);
+                error = null;
+            } catch (Throwable t) {
+                conn = null;
+                error = t;
+            }
+
+            synchronized (this) {
+                if (abandoned) {
+                    if (conn != null) {
+                        try {
+                            conn.close();
+                        } catch (SQLException e) {}
+                    }
+                } else {
+                    result = conn;
+                    resultException = error;
+                    notify();
+                }
+            }
+        }
+
+        /**
+         * Get the connection result from this (assumed running) thread.
+         * If the timeout is reached without a result being available,
+         * a SQLException is thrown.
+         *
+         * @param timeout timeout in milliseconds
+         * @return the new connection, if successful
+         * @throws SQLException if a connection error occurs or the timeout is reached
+         */
+        public Connection getResult(long timeout) throws SQLException {
+            long expiry = System.currentTimeMillis() + timeout;
+            synchronized (this) {
+                while (true) {
+                    if (result != null)
+                        return result;
+                    
+                    if (resultException != null) {
+                        if (resultException instanceof SQLException) {
+                            resultException.fillInStackTrace();
+                            throw (SQLException)resultException;
+                        } else {
+                            throw new PSQLException(GT.tr("Something unusual has occured to cause the driver to fail. Please report this exception."),
+                                                    PSQLState.UNEXPECTED_ERROR, resultException);
+                        }
+                    }
+                    
+                    long delay = expiry - System.currentTimeMillis();
+                    if (delay <= 0) {
+                        abandoned = true;
+                        throw new PSQLException(GT.tr("Connection attempt timed out."),
+                                                PSQLState.CONNECTION_UNABLE_TO_CONNECT);
+                    }
+                    
+                    try {
+                        wait(delay);
+                    } catch (InterruptedException ie) {
+                        abandoned = true;
+                        throw new PSQLException(GT.tr("Interrupted while attempting to connect."),
+                                                PSQLState.CONNECTION_UNABLE_TO_CONNECT);
+                    }                                            
+                }
+            }
+        }
+
+        private final String url;
+        private final Properties props;
+        private Connection result;
+        private Throwable resultException;
+        private boolean abandoned;
+    }
+
+    /**
+     * Create a connection from URL and properties. Always
+     * does the connection work in the current thread without
+     * enforcing a timeout, regardless of any timeout specified
+     * in the properties.
+     *
+     * @param url the original URL
+     * @param props the parsed/defaulted connection properties
+     * @return a new connection
+     * @throws SQLException if the connection could not be made
+     */
+    private static Connection makeConnection(String url, Properties props) throws SQLException {
+        return new org.postgresql.driver.jdbc3.Jdbc3Connection(host(props), port(props),
+                                      user(props), database(props),
+                                      props, url);
+    }
+
+    /**
+     * Returns true if the driver thinks it can open a connection to the
+     * given URL.  Typically, drivers will return true if they understand
+     * the subprotocol specified in the URL and false if they don't.  Our
+     * protocols start with jdbc:postgresql:
+     *
+     * @see java.sql.Driver#acceptsURL
+     * @param url the URL of the driver
+     * @return true if this driver accepts the given URL
+     * @exception SQLException if a database-access error occurs
+     * (Dont know why it would *shrug*)
+     */
+    public boolean acceptsURL(String url) throws SQLException
+    {
+        if (parseURL(url, null) == null)
+            return false;
+        return true;
+    }
+
+    private static final Object[][] knownProperties = {
+                { "PGDBNAME", Boolean.TRUE,
+                  "Database name to connect to; may be specified directly in the JDBC URL." },
+                { "user", Boolean.TRUE,
+                  "Username to connect to the database as.", null },
+                { "PGHOST", Boolean.FALSE,
+                  "Hostname of the PostgreSQL server; may be specified directly in the JDBC URL." },
+                { "PGPORT", Boolean.FALSE,
+                  "Port number to connect to the PostgreSQL server on; may be specified directly in the JDBC URL.", },
+                { "password", Boolean.FALSE,
+                  "Password to use when authenticating.", },
+                { "protocolVersion", Boolean.FALSE,
+                  "Force use of a particular protocol version when connecting; if set, disables protocol version fallback.", },
+                { "ssl", Boolean.FALSE,
+                  "Control use of SSL; any nonnull value causes SSL to be required." },
+                { "sslfactory", Boolean.FALSE,
+                  "Provide a SSLSocketFactory class when using SSL." },
+                { "sslfactoryarg", Boolean.FALSE,
+                  "Argument forwarded to constructor of SSLSocketFactory class." },
+                { "loglevel", Boolean.FALSE,
+                  "Control the driver's log verbosity: 0 is off, 1 is INFO, 2 is DEBUG.",
+                  new String[] { "0", "1", "2" } },
+                { "allowEncodingChanges", Boolean.FALSE,
+                  "Allow the user to change the client_encoding variable." },
+                { "logUnclosedConnections", Boolean.FALSE,
+                  "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)." },
+                { "charSet", Boolean.FALSE,
+                  "When connecting to a pre-7.3 server, the database encoding to assume is in use." },
+                { "compatible", Boolean.FALSE,
+                  "Force compatibility of some features with an older version of the driver.",
+                  new String[] { "7.1", "7.2", "7.3", "7.4", "8.0", "8.1", "8.2" } },
+                { "loginTimeout", Boolean.FALSE,
+                  "The login timeout, in seconds; 0 means no timeout beyond the normal TCP connection timout." },
+                { "socketTimeout", Boolean.FALSE,
+                  "The timeout value for socket read operations, in seconds; 0 means no timeout." },
+                { "tcpKeepAlive", Boolean.FALSE,
+                  "Enable or disable TCP keep-alive probe." },
+                { "stringtype", Boolean.FALSE,
+                  "The type to bind String parameters as (usually 'varchar'; 'unspecified' allows implicit casting to other types)",
+                  new String[] { "varchar", "unspecified" } },
+                { "kerberosServerName", Boolean.FALSE,
+                  "The Kerberos service name to use when authenticating with GSSAPI.  This is equivalent to libpq's PGKRBSRVNAME environment variable." },
+                { "jaasApplicationName", Boolean.FALSE,
+                  "Specifies the name of the JAAS system or application login configuration." }
+            };
+
+    /**
+     * The getPropertyInfo method is intended to allow a generic GUI
+     * tool to discover what properties it should prompt a human for
+     * in order to get enough information to connect to a database.
+     *
+     * <p>Note that depending on the values the human has supplied so
+     * far, additional values may become necessary, so it may be necessary
+     * to iterate through several calls to getPropertyInfo
+     *
+     * @param url the Url of the database to connect to
+     * @param info a proposed list of tag/value pairs that will be sent on
+     * connect open.
+     * @return An array of DriverPropertyInfo objects describing
+     * possible properties.  This array may be an empty array if
+     * no properties are required
+     * @exception SQLException if a database-access error occurs
+     * @see java.sql.Driver#getPropertyInfo
+     */
+    public DriverPropertyInfo[] getPropertyInfo(String url, Properties info) throws SQLException
+    {
+        Properties copy = new Properties(info);
+        parseURL(url, copy);
+
+        DriverPropertyInfo[] props = new DriverPropertyInfo[knownProperties.length];
+        for (int i = 0; i < knownProperties.length; ++i)
+        {
+            String name = (String) knownProperties[i][0];
+            props[i] = new DriverPropertyInfo(name, copy.getProperty(name));
+            props[i].required = ((Boolean) knownProperties[i][1]).booleanValue();
+            props[i].description = (String) knownProperties[i][2];
+            if (knownProperties[i].length > 3)
+                props[i].choices = (String[]) knownProperties[i][3];
+        }
+
+        return props;
+    }
+
+    public static final int MAJORVERSION = 9;
+    /**
+     * Gets the drivers major version number
+     *
+     * @return the drivers major version number
+     */
+    public int getMajorVersion()
+    {
+        return MAJORVERSION;
+    }
+
+
+    public static final int MINORVERSION = 0;
+    /**
+     * Get the drivers minor version number
+     *
+     * @return the drivers minor version number
+     */
+    public int getMinorVersion()
+    {
+        return MINORVERSION;
+    }
+
+    /**
+     * Returns the server version series of this driver and the
+     * specific build number.
+     */
+    public static String getVersion()
+    {
+        return "PostgreSQL 9.0 JDBC4 (build " + PSQLDriverVersion.buildNumber + ")";
+    }
+
+    /**
+     * Report whether the driver is a genuine JDBC compliant driver.  A
+     * driver may only report "true" here if it passes the JDBC compliance
+     * tests, otherwise it is required to return false.  JDBC compliance
+     * requires full support for the JDBC API and full support for SQL 92
+     * Entry Level.
+     *
+     * <p>For PostgreSQL, this is not yet possible, as we are not SQL92
+     * compliant (yet).
+     */
+    public boolean jdbcCompliant()
+    {
+        return false;
+    }
+
+    static private String[] protocols = { "jdbc", "postgresql" };
+
+    /**
+     * Constructs a new DriverURL, splitting the specified URL into its
+     * component parts
+     * @param url JDBC URL to parse
+     * @param defaults Default properties
+     * @return Properties with elements added from the url
+     * @exception SQLException
+     */
+    Properties parseURL(String url, Properties defaults) throws SQLException
+    {
+        int state = -1;
+        Properties urlProps = new Properties(defaults);
+
+        String l_urlServer = url;
+        String l_urlArgs = "";
+
+        int l_qPos = url.indexOf('?');
+        if (l_qPos != -1)
+        {
+            l_urlServer = url.substring(0, l_qPos);
+            l_urlArgs = url.substring(l_qPos + 1);
+        }
+
+        // look for an IPv6 address that is enclosed by []
+        // the upcoming parsing that uses colons as identifiers can't handle
+        // the colons in an IPv6 address.
+        int ipv6start = l_urlServer.indexOf("[");
+        int ipv6end = l_urlServer.indexOf("]");
+        String ipv6address = null;
+        if (ipv6start != -1 && ipv6end > ipv6start)
+        {
+            ipv6address = l_urlServer.substring(ipv6start + 1, ipv6end);
+            l_urlServer = l_urlServer.substring(0, ipv6start) + "ipv6host" + l_urlServer.substring(ipv6end + 1);
+        }
+
+        //parse the server part of the url
+        StringTokenizer st = new StringTokenizer(l_urlServer, ":/", true);
+        int count;
+        for (count = 0; (st.hasMoreTokens()); count++)
+        {
+            String token = st.nextToken();
+
+            // PM Aug 2 1997 - Modified to allow multiple backends
+            if (count <= 3)
+            {
+                if ((count % 2) == 1 && token.equals(":"))
+                    ;
+                else if ((count % 2) == 0)
+                {
+                    boolean found = (count == 0) ? true : false;
+                    for (int tmp = 0;tmp < protocols.length;tmp++)
+                    {
+                        if (token.equals(protocols[tmp]))
+                        {
+                            // PM June 29 1997 Added this property to enable the driver
+                            // to handle multiple backend protocols.
+                            if (count == 2 && tmp > 0)
+                            {
+                                urlProps.setProperty("Protocol", token);
+                                found = true;
+                            }
+                        }
+                    }
+
+                    if (found == false)
+                        return null;
+                }
+                else
+                    return null;
+            }
+            else if (count > 3)
+            {
+                if (count == 4 && token.equals("/"))
+                    state = 0;
+                else if (count == 4)
+                {
+                    urlProps.setProperty("PGDBNAME", token);
+                    state = -2;
+                }
+                else if (count == 5 && state == 0 && token.equals("/"))
+                    state = 1;
+                else if (count == 5 && state == 0)
+                    return null;
+                else if (count == 6 && state == 1)
+                    urlProps.setProperty("PGHOST", token);
+                else if (count == 7 && token.equals(":"))
+                    state = 2;
+                else if (count == 8 && state == 2)
+                {
+                    try
+                    {
+                        Integer portNumber = Integer.decode(token);
+                        urlProps.setProperty("PGPORT", portNumber.toString());
+                    }
+                    catch (Exception e)
+                    {
+                        return null;
+                    }
+                }
+                else if ((count == 7 || count == 9) &&
+                         (state == 1 || state == 2) && token.equals("/"))
+                    state = -1;
+                else if (state == -1)
+                {
+                    urlProps.setProperty("PGDBNAME", token);
+                    state = -2;
+                }
+            }
+        }
+        if (count <= 1)
+        {
+            return null;
+        }
+
+        // if we extracted an IPv6 address out earlier put it back
+        if (ipv6address != null)
+            urlProps.setProperty("PGHOST", ipv6address);
+
+        //parse the args part of the url
+        StringTokenizer qst = new StringTokenizer(l_urlArgs, "&");
+        for (count = 0; (qst.hasMoreTokens()); count++)
+        {
+            String token = qst.nextToken();
+            int l_pos = token.indexOf('=');
+            if (l_pos == -1)
+            {
+                urlProps.setProperty(token, "");
+            }
+            else
+            {
+                urlProps.setProperty(token.substring(0, l_pos), token.substring(l_pos + 1));
+            }
+        }
+
+        return urlProps;
+    }
+
+    /**
+     * @return the hostname portion of the URL
+     */
+    private static String host(Properties props)
+    {
+        return props.getProperty("PGHOST", "localhost");
+    }
+
+    /**
+     * @return the port number portion of the URL or the default if no port was specified
+     */
+    private static int port(Properties props)
+    {
+        return Integer.parseInt(props.getProperty("PGPORT", "5432"));
+    }
+
+    /**
+     * @return the username of the URL
+     */
+    private static String user(Properties props)
+    {
+        return props.getProperty("user", "");
+    }
+
+    /**
+     * @return the database name of the URL
+     */
+    private static String database(Properties props)
+    {
+        return props.getProperty("PGDBNAME", "");
+    }
+
+    /**
+     * @return the timeout from the URL, in milliseconds
+     */
+    private static long timeout(Properties props)
+    {
+        String timeout = props.getProperty("loginTimeout");
+        if (timeout != null) {
+            try {
+                return (long) (Float.parseFloat(timeout) * 1000);
+            } catch (NumberFormatException e) {
+                // Log level isn't set yet, so this doesn't actually 
+                // get printed.
+                logger.debug("Couldn't parse loginTimeout value: " + timeout);
+            }
+        }
+        return DriverManager.getLoginTimeout() * 1000;
+    }
+
+    /*
+     * This method was added in v6.5, and simply throws an SQLException
+     * for an unimplemented method. I decided to do it this way while
+     * implementing the JDBC2 extensions to JDBC, as it should help keep the
+     * overall driver size down.
+     * It now requires the call Class and the function name to help when the
+     * driver is used with closed software that don't report the stack strace
+     * @param callClass the call Class
+     * @param functionName the name of the unimplemented function with the type
+     *  of its arguments
+     * @return PSQLException with a localized message giving the complete 
+     *  description of the unimplemeted function
+     */
+    public static SQLException notImplemented(Class callClass, String functionName)
+    {
+        return new PSQLException(GT.tr("Method {0} is not yet implemented.", callClass.getName() + "." + functionName),
+                                 PSQLState.NOT_IMPLEMENTED);
+    }
+
+    /**
+    * used to turn logging on to a certain level, can be called
+    * by specifying fully qualified class ie org.postgresql.Driver.setLogLevel()
+    * @param logLevel sets the level which logging will respond to
+    * INFO being almost no messages
+    * DEBUG most verbose
+    */
+    public static void setLogLevel(int logLevel)
+    {
+        synchronized (Driver.class) {
+            logger.setLogLevel(logLevel);
+            logLevelSet = true;
+        }
+    }
+
+    public static int getLogLevel()
+    {
+        synchronized (Driver.class) {
+            return logger.getLogLevel();
+        }
+    }
+
+}

=== added file 'src/org/postgresql/driver/PGConnection.java'
--- src/org/postgresql/driver/PGConnection.java	1970-01-01 00:00:00 +0000
+++ src/org/postgresql/driver/PGConnection.java	2011-08-30 20:30:24 +0000
@@ -0,0 +1,116 @@
+/*****************************************************************************
+ * Copyright (C) 2008 EnterpriseDB Corporation.
+ * Copyright (C) 2011 Stado Global Development Group.
+ *
+ * This file is part of Stado.
+ *
+ * Stado is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Stado is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Stado.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * You can find Stado at http://www.stado.us
+ *
+ ****************************************************************************/
+package org.postgresql.driver;
+
+import java.sql.*;
+
+import org.postgresql.driver.copy.CopyManager;
+
+/**
+ *  This interface defines the public PostgreSQL extensions to
+ *  java.sql.Connection. All Connections returned by the PostgreSQL driver
+ *  implement PGConnection.
+ */
+public interface PGConnection
+{
+    /**
+     * This method returns any notifications that have been received
+     * since the last call to this method.
+     * Returns null if there have been no notifications.
+     * @since 7.3
+     */
+    public PGNotification[] getNotifications() throws SQLException;
+
+    /**
+     * This returns the COPY API for the current connection.
+     * @since 8.4
+     */
+    public CopyManager getCopyAPI() throws SQLException;
+
+    /**
+     * This allows client code to add a handler for one of org.postgresql's
+     * more unique data types. It is approximately equivalent to
+     * <code>addDataType(type, Class.forName(name))</code>.
+     *
+     * @deprecated As of 8.0, replaced by
+     *   {@link #addDataType(String,Class)}. This deprecated method does not
+     *   work correctly for registering classes that cannot be directly loaded
+     *   by the JDBC driver's classloader.
+     * @throws RuntimeException if the type cannot be registered (class not
+     *   found, etc).
+     */
+    public void addDataType(String type, String name);
+
+    /**
+     * This allows client code to add a handler for one of org.postgresql's
+     * more unique data types. 
+     *
+     * <p><b>NOTE:</b> This is not part of JDBC, but an extension.
+     *
+     * <p>The best way to use this is as follows:
+     *
+     * <p><pre>
+     * ...
+     * ((org.postgresql.PGConnection)myconn).addDataType("mytype", my.class.name.class);
+     * ...
+     * </pre>
+     *
+     * <p>where myconn is an open Connection to org.postgresql.
+     *
+     * <p>The handling class must extend org.postgresql.driver.util.PGobject
+     *
+     * @since 8.0 
+     *
+     * @param type the PostgreSQL type to register
+     * @param klass the class implementing the Java representation of the type;
+     *    this class must implement {@link org.postgresql.driver.util.PGobject}).
+     *
+     * @throws SQLException if <code>klass</code> does not implement
+     *    {@link org.postgresql.driver.util.PGobject}).
+     *
+     * @see org.postgresql.driver.util.PGobject
+     */
+    public void addDataType(String type, Class klass)
+    throws SQLException;
+
+    /**
+     * Set the default statement reuse threshold before enabling server-side
+     * prepare. See {@link org.postgresql.driver.PGStatement#setPrepareThreshold(int)} for 
+     * details.
+     *
+     * @since build 302
+     * @param threshold the new threshold
+     */
+    public void setPrepareThreshold(int threshold);
+
+    /**
+     * Get the default server-side prepare reuse threshold for statements created
+     * from this connection.
+     *
+     * @since build 302
+     * @return the current threshold
+     */
+    public int getPrepareThreshold();
+
+}
+

=== added file 'src/org/postgresql/driver/PGNotification.java'
--- src/org/postgresql/driver/PGNotification.java	1970-01-01 00:00:00 +0000
+++ src/org/postgresql/driver/PGNotification.java	2011-08-30 20:30:24 +0000
@@ -0,0 +1,52 @@
+/*****************************************************************************
+ * Copyright (C) 2008 EnterpriseDB Corporation.
+ * Copyright (C) 2011 Stado Global Development Group.
+ *
+ * This file is part of Stado.
+ *
+ * Stado is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Stado is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Stado.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * You can find Stado at http://www.stado.us
+ *
+ ****************************************************************************/
+package org.postgresql.driver;
+
+/**
+ *    This interface defines the public PostgreSQL extension for Notifications
+ */
+public interface PGNotification
+{
+    /**
+     * Returns name of this notification
+     * @since 7.3
+     */
+    public String getName();
+
+    /**
+     * Returns the process id of the backend process making this notification
+     * @since 7.3
+     */
+    public int getPID();
+
+    /**
+     * Returns additional information from the notifying process.
+     * This feature has only been implemented in server versions 9.0
+     * and later, so previous versions will always return an empty String.
+     *
+     * @since 8.0
+     */
+    public String getParameter();
+
+}
+

=== added file 'src/org/postgresql/driver/PGRefCursorResultSet.java'
--- src/org/postgresql/driver/PGRefCursorResultSet.java	1970-01-01 00:00:00 +0000
+++ src/org/postgresql/driver/PGRefCursorResultSet.java	2011-08-30 20:30:24 +0000
@@ -0,0 +1,40 @@
+/*****************************************************************************
+ * Copyright (C) 2008 EnterpriseDB Corporation.
+ * Copyright (C) 2011 Stado Global Development Group.
+ *
+ * This file is part of Stado.
+ *
+ * Stado is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Stado is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Stado.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * You can find Stado at http://www.stado.us
+ *
+ ****************************************************************************/
+package org.postgresql.driver;
+
+/**
+ * A ref cursor based result set.
+ *
+ * @deprecated As of 8.0, this interface is only present for backwards-
+ *   compatibility purposes. New code should call getString() on the ResultSet
+ *   that contains the refcursor to obtain the underlying cursor name.
+ */
+public interface PGRefCursorResultSet
+{
+
+    /** @return the name of the cursor.
+     *  @deprecated As of 8.0, replaced with calling getString() on
+     *    the ResultSet that this ResultSet was obtained from.
+     */
+    public String getRefCursor ();
+}

=== added file 'src/org/postgresql/driver/PGResultSetMetaData.java'
--- src/org/postgresql/driver/PGResultSetMetaData.java	1970-01-01 00:00:00 +0000
+++ src/org/postgresql/driver/PGResultSetMetaData.java	2011-08-30 20:30:24 +0000
@@ -0,0 +1,54 @@
+/*****************************************************************************
+ * Copyright (C) 2008 EnterpriseDB Corporation.
+ * Copyright (C) 2011 Stado Global Development Group.
+ *
+ * This file is part of Stado.
+ *
+ * Stado is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Stado is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Stado.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * You can find Stado at http://www.stado.us
+ *
+ ****************************************************************************/
+package org.postgresql.driver;
+
+import java.sql.SQLException;
+
+public interface PGResultSetMetaData
+{
+
+    /**
+     * Returns the underlying column name of a query result, or ""
+     * if it is unable to be determined.
+     * 
+     * @since 8.0
+     */
+    public String getBaseColumnName(int column) throws SQLException;
+
+    /**
+     * Returns the underlying table name of query result, or ""
+     * if it is unable to be determined.
+     *
+     * @since 8.0
+     */
+    public String getBaseTableName(int column) throws SQLException;
+
+    /**
+     * Returns the underlying table name of query result, or ""
+     * if it is unable to be determined.
+     *
+     * @since 8.0
+     */
+    public String getBaseSchemaName(int column) throws SQLException;
+
+}

=== added file 'src/org/postgresql/driver/PGStatement.java'
--- src/org/postgresql/driver/PGStatement.java	1970-01-01 00:00:00 +0000
+++ src/org/postgresql/driver/PGStatement.java	2011-08-30 20:30:24 +0000
@@ -0,0 +1,98 @@
+/*****************************************************************************
+ * Copyright (C) 2008 EnterpriseDB Corporation.
+ * Copyright (C) 2011 Stado Global Development Group.
+ *
+ * This file is part of Stado.
+ *
+ * Stado is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Stado is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Stado.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * You can find Stado at http://www.stado.us
+ *
+ ****************************************************************************/
+package org.postgresql.driver;
+
+import java.sql.*;
+
+/**
+ *  This interface defines the public PostgreSQL extensions to
+ *  java.sql.Statement. All Statements constructed by the PostgreSQL
+ *  driver implement PGStatement.
+ */
+public interface PGStatement
+{
+    // We can't use Long.MAX_VALUE or Long.MIN_VALUE for java.sql.date
+    // because this would break the 'normalization contract' of the
+    // java.sql.Date API.
+    // The follow values are the nearest MAX/MIN values with hour,
+    // minute, second, millisecond set to 0 - this is used for
+    // -infinity / infinity representation in Java
+    public static final long DATE_POSITIVE_INFINITY = 9223372036825200000l;
+    public static final long DATE_NEGATIVE_INFINITY = -9223372036832400000l;
+
+
+    /**
+     * Returns the Last inserted/updated oid.
+     * @return OID of last insert
+        * @since 7.3
+     */
+    public long getLastOID() throws SQLException;
+
+    /**
+     * Turn on the use of prepared statements in the server (server side
+     * prepared statements are unrelated to jdbc PreparedStatements)
+     * As of build 302, this method is equivalent to
+     *  <code>setPrepareThreshold(1)</code>.
+     *
+     * @deprecated As of build 302, replaced by {@link #setPrepareThreshold(int)}
+        * @since 7.3
+     */
+    public void setUseServerPrepare(boolean flag) throws SQLException;
+
+    /**
+     * Checks if this statement will be executed as a server-prepared
+     * statement. A return value of <code>true</code> indicates that the next
+     * execution of the statement will be done as a server-prepared statement,
+     * assuming the underlying protocol supports it.
+     *
+     * @return true if the next reuse of this statement will use a
+     *  server-prepared statement
+     */
+    public boolean isUseServerPrepare();
+
+    /**
+     * Sets the reuse threshold for using server-prepared statements.
+     *<p>
+     * If <code>threshold</code> is a non-zero value N, the Nth and subsequent
+     * reuses of a PreparedStatement will use server-side prepare.
+     *<p>
+     * If <code>threshold</code> is zero, server-side prepare will not be used.
+     *<p>
+     * The reuse threshold is only used by PreparedStatement and
+     * CallableStatement objects; it is ignored for plain Statements.
+     *
+     * @since build 302
+     * @param threshold the new threshold for this statement
+     * @throws SQLException if an exception occurs while changing the threshold
+     */
+    public void setPrepareThreshold(int threshold) throws SQLException;
+
+    /**
+     * Gets the server-side prepare reuse threshold in use for this statement.
+     *
+     * @since build 302
+     * @return the current threshold
+     * @see #setPrepareThreshold(int)
+     */
+    public int getPrepareThreshold();
+}

=== added directory 'src/org/postgresql/driver/copy'
=== added file 'src/org/postgresql/driver/copy/CopyIn.java'
--- src/org/postgresql/driver/copy/CopyIn.java	1970-01-01 00:00:00 +0000
+++ src/org/postgresql/driver/copy/CopyIn.java	2011-08-30 20:30:24 +0000
@@ -0,0 +1,56 @@
+/*****************************************************************************
+ * Copyright (C) 2008 EnterpriseDB Corporation.
+ * Copyright (C) 2011 Stado Global Development Group.
+ *
+ * This file is part of Stado.
+ *
+ * Stado is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Stado is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Stado.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * You can find Stado at http://www.stado.us
+ *
+ ****************************************************************************/
+package org.postgresql.driver.copy;
+
+import java.sql.SQLException;
+
+/**
+ * Copy bulk data from client into a PostgreSQL table very fast.
+ */
+public interface CopyIn extends CopyOperation {
+
+    /**
+     * Writes specified part of given byte array to an open and writable copy operation.
+     * @param buf array of bytes to write
+     * @param off offset of first byte to write (normally zero)
+     * @param siz number of bytes to write (normally buf.length)
+     * @throws SQLException if the operation fails
+     */
+    void writeToCopy(byte[] buf, int off, int siz) throws SQLException;
+
+    /**
+     * Force any buffered output to be sent over the network to the
+     * backend.  In general this is a useless operation as it will get
+     * pushed over in due time or when endCopy is called.  Some specific
+     * modified server versions (Truviso) want this data sooner.
+     * If you are unsure if you need to use this method, don't.
+     */
+    void flushCopy() throws SQLException;
+    
+    /**
+     * Finishes copy operation succesfully.
+     * @return number of updated rows for server 8.2 or newer (see getHandledRowCount())
+     * @throws SQLException if the operation fails.
+     */
+    public long endCopy() throws SQLException;
+}

=== added file 'src/org/postgresql/driver/copy/CopyManager.java'
--- src/org/postgresql/driver/copy/CopyManager.java	1970-01-01 00:00:00 +0000
+++ src/org/postgresql/driver/copy/CopyManager.java	2011-08-30 20:30:24 +0000
@@ -0,0 +1,202 @@
+/*****************************************************************************
+ * Copyright (C) 2008 EnterpriseDB Corporation.
+ * Copyright (C) 2011 Stado Global Development Group.
+ *
+ * This file is part of Stado.
+ *
+ * Stado is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Stado is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Stado.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * You can find Stado at http://www.stado.us
+ *
+ ****************************************************************************/
+
+/**
+ * Bulk data copy for PostgreSQL
+ */
+package org.postgresql.driver.copy;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.InputStream;
+import java.io.Reader;
+import java.io.Writer;
+import java.sql.SQLException;
+
+import org.postgresql.driver.core.BaseConnection;
+import org.postgresql.driver.core.Encoding;
+import org.postgresql.driver.core.QueryExecutor;
+import org.postgresql.driver.util.GT;
+import org.postgresql.driver.util.PSQLException;
+import org.postgresql.driver.util.PSQLState;
+
+/**
+ * API for PostgreSQL COPY bulk data transfer
+ */
+public class CopyManager {
+    // I don't know what the best buffer size is, so we let people specify it if
+    // they want, and if they don't know, we don't make them guess, so that if we
+    // do figure it out we can just set it here and they reap the rewards.
+    // Note that this is currently being used for both a number of bytes and a number
+    // of characters.
+    final static int DEFAULT_BUFFER_SIZE = 65536;
+
+    private final Encoding encoding;
+    private final QueryExecutor queryExecutor;
+    private final BaseConnection connection;
+
+    public CopyManager(BaseConnection connection) throws SQLException {
+        this.encoding = connection.getEncoding();
+        this.queryExecutor = connection.getQueryExecutor();
+        this.connection = connection;
+    }
+
+    public CopyIn copyIn(String sql) throws SQLException {
+        CopyOperation op = null;
+        try {
+            op = queryExecutor.startCopy(sql, connection.getAutoCommit());
+            return (CopyIn) op;
+        } catch(ClassCastException cce) {
+            op.cancelCopy();
+            throw new PSQLException(GT.tr("Requested CopyIn but got {0}", op.getClass().getName()), PSQLState.WRONG_OBJECT_TYPE, cce);
+        }
+    }
+
+    public CopyOut copyOut(String sql) throws SQLException {
+        CopyOperation op = null;
+        try {
+            op = queryExecutor.startCopy(sql, connection.getAutoCommit());
+            return (CopyOut) op;
+        } catch(ClassCastException cce) {
+            op.cancelCopy();
+            throw new PSQLException(GT.tr("Requested CopyOut but got {0}", op.getClass().getName()), PSQLState.WRONG_OBJECT_TYPE, cce);
+        }
+    }
+
+    /**
+     * Pass results of a COPY TO STDOUT query from database into a Writer.
+     * @param sql COPY TO STDOUT statement
+     * @param to the stream to write the results to (row by row)
+     * @return number of rows updated for server 8.2 or newer; -1 for older
+     * @throws SQLException on database usage errors
+     * @throws IOException upon writer or database connection failure
+     */
+    public long copyOut(final String sql, Writer to) throws SQLException, IOException {
+        byte[] buf;
+        CopyOut cp = copyOut(sql);
+        try {
+            while ( (buf = cp.readFromCopy()) != null ) {
+                to.write(encoding.decode(buf));
+            }
+            return cp.getHandledRowCount();
+        } finally { // see to it that we do not leave the connection locked
+            if(cp.isActive())
+                cp.cancelCopy();
+        }
+    }
+
+    /**
+     * Pass results of a COPY TO STDOUT query from database into an OutputStream.
+     * @param sql COPY TO STDOUT statement
+     * @param to the stream to write the results to (row by row)
+     * @return number of rows updated for server 8.2 or newer; -1 for older
+     * @throws SQLException on database usage errors
+     * @throws IOException upon output stream or database connection failure
+     */
+    public long copyOut(final String sql, OutputStream to) throws SQLException, IOException {
+        byte[] buf;
+        CopyOut cp = copyOut(sql);
+        try {
+            while( (buf = cp.readFromCopy()) != null ) {
+                to.write(buf);
+            }
+            return cp.getHandledRowCount();
+        } finally { // see to it that we do not leave the connection locked
+            if(cp.isActive())
+                cp.cancelCopy();
+        }
+    }
+
+    /**
+     * Use COPY FROM STDIN for very fast copying from a Reader into a database table.
+     * @param sql COPY FROM STDIN statement
+     * @param from a CSV file or such
+     * @return number of rows updated for server 8.2 or newer; -1 for older
+     * @throws SQLException on database usage issues
+     * @throws IOException upon reader or database connection failure
+     */
+    public long copyIn(final String sql, Reader from) throws SQLException, IOException {
+        return copyIn(sql, from, DEFAULT_BUFFER_SIZE);
+    }
+
+    /**
+     * Use COPY FROM STDIN for very fast copying from a Reader into a database table.
+     * @param sql COPY FROM STDIN statement
+     * @param from a CSV file or such
+     * @param bufferSize number of characters to buffer and push over network to server at once
+     * @return number of rows updated for server 8.2 or newer; -1 for older
+     * @throws SQLException on database usage issues
+     * @throws IOException upon reader or database connection failure
+     */
+    public long copyIn(final String sql, Reader from, int bufferSize) throws SQLException, IOException {
+        char[] cbuf = new char[bufferSize];
+        int len;
+        CopyIn cp = copyIn(sql);
+        try {
+            while ( (len = from.read(cbuf)) > 0) {
+                byte[] buf = encoding.encode(new String(cbuf, 0, len));
+                cp.writeToCopy(buf, 0, buf.length);
+            }
+            return cp.endCopy();
+        } finally { // see to it that we do not leave the connection locked
+            if(cp.isActive())
+                cp.cancelCopy();
+        }
+    }
+
+    /**
+     * Use COPY FROM STDIN for very fast copying from an InputStream into a database table.
+     * @param sql COPY FROM STDIN statement
+     * @param from a CSV file or such
+     * @return number of rows updated for server 8.2 or newer; -1 for older
+     * @throws SQLException on database usage issues
+     * @throws IOException upon input stream or database connection failure
+     */
+    public long copyIn(final String sql, InputStream from) throws SQLException, IOException {
+        return copyIn(sql, from, DEFAULT_BUFFER_SIZE);
+    }
+
+    /**
+     * Use COPY FROM STDIN for very fast copying from an InputStream into a database table.
+     * @param sql COPY FROM STDIN statement
+     * @param from a CSV file or such
+     * @param bufferSize number of bytes to buffer and push over network to server at once
+     * @return number of rows updated for server 8.2 or newer; -1 for older
+     * @throws SQLException on database usage issues
+     * @throws IOException upon input stream or database connection failure
+     */
+    public long copyIn(final String sql, InputStream from, int bufferSize) throws SQLException, IOException {
+        byte[] buf = new byte[bufferSize];
+        int len;
+        CopyIn cp = copyIn(sql);
+        try {
+            while( (len = from.read(buf)) > 0 ) {
+                cp.writeToCopy(buf, 0, len);
+            }
+            return cp.endCopy();
+        } finally { // see to it that we do not leave the connection locked
+            if(cp.isActive())
+                cp.cancelCopy();
+        }
+    }
+}

=== added file 'src/org/postgresql/driver/copy/CopyOperation.java'
--- src/org/postgresql/driver/copy/CopyOperation.java	1970-01-01 00:00:00 +0000
+++ src/org/postgresql/driver/copy/CopyOperation.java	2011-08-30 20:30:24 +0000
@@ -0,0 +1,68 @@
+/*****************************************************************************
+ * Copyright (C) 2008 EnterpriseDB Corporation.
+ * Copyright (C) 2011 Stado Global Development Group.
+ *
+ * This file is part of Stado.
+ *
+ * Stado is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Stado is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Stado.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * You can find Stado at http://www.stado.us
+ *
+ ****************************************************************************/
+package org.postgresql.driver.copy;
+
+import java.sql.SQLException;
+
+/**
+ * Exchange bulk data between client and PostgreSQL database tables.
+ * See CopyIn and CopyOut for full interfaces for corresponding copy directions.
+ */
+public interface CopyOperation {
+
+    /**
+     * @return number of fields in each row for this operation
+     */
+    int getFieldCount();
+
+    /**
+     * @return overall format of each row: 0 = textual, 1 = binary
+     */
+    int getFormat();
+
+    /**
+     * @param field number of field (0..fieldCount()-1)
+     * @return format of requested field: 0 = textual, 1 = binary
+     */
+    int getFieldFormat(int field);
+    
+    /**
+     * @return is connection reserved for this Copy operation?
+     */
+    boolean isActive();
+    
+    /**
+     * Cancels this copy operation, discarding any exchanged data.
+     * @throws SQLException if cancelling fails
+     */
+    void cancelCopy() throws SQLException;
+
+    /**
+     * After succesful end of copy, returns the number
+     * of database records handled in that operation.
+     * Only implemented in PostgreSQL server version 8.2 and up.
+     * Otherwise, returns -1.
+     * @return number of handled rows or -1
+     */
+    public long getHandledRowCount();
+}

=== added file 'src/org/postgresql/driver/copy/CopyOut.java'
--- src/org/postgresql/driver/copy/CopyOut.java	1970-01-01 00:00:00 +0000
+++ src/org/postgresql/driver/copy/CopyOut.java	2011-08-30 20:30:24 +0000
@@ -0,0 +1,29 @@
+/*****************************************************************************
+ * Copyright (C) 2008 EnterpriseDB Corporation.
+ * Copyright (C) 2011 Stado Global Development Group.
+ *
+ * This file is part of Stado.
+ *
+ * Stado is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Stado is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Stado.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * You can find Stado at http://www.stado.us
+ *
+ ****************************************************************************/
+package org.postgresql.driver.copy;
+
+import java.sql.SQLException;
+
+public interface CopyOut extends CopyOperation {
+    byte[] readFromCopy() throws SQLException;
+}

=== added file 'src/org/postgresql/driver/copy/PGCopyInputStream.java'
--- src/org/postgresql/driver/copy/PGCopyInputStream.java	1970-01-01 00:00:00 +0000
+++ src/org/postgresql/driver/copy/PGCopyInputStream.java	2011-08-30 20:30:24 +0000
@@ -0,0 +1,166 @@
+/*****************************************************************************
+ * Copyright (C) 2008 EnterpriseDB Corporation.
+ * Copyright (C) 2011 Stado Global Development Group.
+ *
+ * This file is part of Stado.
+ *
+ * Stado is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Stado is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Stado.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * You can find Stado at http://www.stado.us
+ *
+ ****************************************************************************/
+package org.postgresql.driver.copy;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.sql.SQLException;
+
+import org.postgresql.driver.PGConnection;
+import org.postgresql.driver.util.GT;
+import org.postgresql.driver.util.PSQLException;
+import org.postgresql.driver.util.PSQLState;
+
+/**
+ * InputStream for reading from a PostgreSQL COPY TO STDOUT operation
+ */
+public class PGCopyInputStream extends InputStream implements CopyOut {
+    private CopyOut op;
+    private byte[] buf;
+    private int at, len;
+
+    /**
+     * Uses given connection for specified COPY TO STDOUT operation
+     * @param connection database connection to use for copying (protocol version 3 required)
+     * @param sql COPY TO STDOUT statement
+     * @throws SQLException if initializing the operation fails
+     */
+    public PGCopyInputStream(PGConnection connection, String sql) throws SQLException {
+        this(connection.getCopyAPI().copyOut(sql));
+    }
+
+    /**
+     * Use given CopyOut operation for reading
+     * @param op COPY TO STDOUT operation
+     * @throws SQLException if initializing the operation fails
+     */
+    public PGCopyInputStream(CopyOut op) {
+        this.op = op;
+    }
+
+    private boolean gotBuf() throws IOException {
+        if(at >= len) {
+            try {
+                buf = op.readFromCopy();
+            } catch(SQLException sqle) {
+                throw new IOException(GT.tr("Copying from database failed: {0}", sqle));
+            }
+            if(buf == null) {
+                at = -1;
+                return false;
+            } else {
+                at = 0;
+                len = buf.length;
+                return true;
+            }
+        }
+        return buf != null;
+    }
+
+    private void checkClosed() throws IOException {
+        if (op == null) {
+            throw new IOException(GT.tr("This copy stream is closed."));
+        }
+    }
+
+    
+    public int available() throws IOException {
+        checkClosed();
+        return ( buf != null ? len - at : 0 );
+    }
+    
+    public int read() throws IOException {
+        checkClosed();
+        return gotBuf() ? buf[at++] : -1;
+    }
+
+    public int read(byte[] buf) throws IOException {
+        return read(buf, 0, buf.length); 
+    }
+    
+    public int read(byte[] buf, int off, int siz) throws IOException {
+        checkClosed();
+        int got = 0;
+        while( got < siz && gotBuf() ) {
+            buf[off+got++] = this.buf[at++];
+        }
+        return got;
+    }
+
+    public byte[] readFromCopy() throws SQLException {
+        byte[] result = buf;
+        try {
+            if(gotBuf()) {
+                if(at>0 || len < buf.length) {
+                    byte[] ba = new byte[len-at];
+                    for(int i=at; i<len; i++)
+                        ba[i-at] = buf[i];
+                    result = ba;
+                }
+                at = len; // either partly or fully returned, buffer is exhausted
+            }
+        } catch(IOException ioe) {
+            throw new PSQLException(GT.tr("Read from copy failed."), PSQLState.CONNECTION_FAILURE);
+        }
+        return result;
+    }
+
+    public void close() throws IOException {
+        // Don't complain about a double close.
+        if (op == null)
+            return;
+
+        try {
+            op.cancelCopy();
+        } catch(SQLException se) {
+            IOException ioe = new IOException("Failed to close copy reader.");
+            ioe.initCause(se);
+            throw ioe;
+        }
+        op = null;
+    }
+
+    public void cancelCopy() throws SQLException {
+        op.cancelCopy();
+    }
+
+    public int getFormat() {
+        return op.getFormat();
+    }
+    
+    public int getFieldFormat(int field) {
+        return op.getFieldFormat(field);
+    }
+
+    public int getFieldCount() {
+        return op.getFieldCount();
+    }
+
+    public boolean isActive() {
+        return op.isActive();
+    }
+
+    public long getHandledRowCount() {
+        return op.getHandledRowCount();
+    }
+}

=== added file 'src/org/postgresql/driver/copy/PGCopyOutputStream.java'
--- src/org/postgresql/driver/copy/PGCopyOutputStream.java	1970-01-01 00:00:00 +0000
+++ src/org/postgresql/driver/copy/PGCopyOutputStream.java	2011-08-30 20:30:24 +0000
@@ -0,0 +1,185 @@
+/*****************************************************************************
+ * Copyright (C) 2008 EnterpriseDB Corporation.
+ * Copyright (C) 2011 Stado Global Development Group.
+ *
+ * This file is part of Stado.
+ *
+ * Stado is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Stado is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Stado.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * You can find Stado at http://www.stado.us
+ *
+ ****************************************************************************/
+package org.postgresql.driver.copy;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.sql.SQLException;
+
+import org.postgresql.driver.PGConnection;
+import org.postgresql.driver.util.GT;
+
+/**
+ * OutputStream for buffered input into a PostgreSQL COPY FROM STDIN operation
+ */
+public class PGCopyOutputStream extends OutputStream implements CopyIn {
+    private CopyIn op;
+    private final byte[] copyBuffer;
+    private final byte[] singleByteBuffer = new byte[1];
+    private int at = 0;
+
+    /**
+     * Uses given connection for specified COPY FROM STDIN operation
+     * @param connection database connection to use for copying (protocol version 3 required)
+     * @param sql COPY FROM STDIN statement
+     * @throws SQLException if initializing the operation fails
+     */
+    public PGCopyOutputStream(PGConnection connection, String sql) throws SQLException {
+        this(connection, sql, CopyManager.DEFAULT_BUFFER_SIZE);
+    }
+
+    /**
+     * Uses given connection for specified COPY FROM STDIN operation
+     * @param connection database connection to use for copying (protocol version 3 required)
+     * @param sql COPY FROM STDIN statement
+     * @param bufferSize try to send this many bytes at a time
+     * @throws SQLException if initializing the operation fails
+     */
+    public PGCopyOutputStream(PGConnection connection, String sql, int bufferSize) throws SQLException {
+        this(connection.getCopyAPI().copyIn(sql), bufferSize);
+    }
+
+    /**
+     * Use given CopyIn operation for writing
+     * @param op COPY FROM STDIN operation
+     */
+    public PGCopyOutputStream(CopyIn op) {
+        this(op, CopyManager.DEFAULT_BUFFER_SIZE);
+    }
+
+    /**
+     * Use given CopyIn operation for writing
+     * @param op COPY FROM STDIN operation
+     * @param bufferSize try to send this many bytes at a time
+     */
+    public PGCopyOutputStream(CopyIn op, int bufferSize) {
+        this.op = op;
+        copyBuffer = new byte[bufferSize];
+    }
+
+    public void write(int b) throws IOException {
+        checkClosed();
+        if(b<0 || b>255)
+            throw new IOException(GT.tr("Cannot write to copy a byte of value {0}", new Integer(b)));
+        singleByteBuffer[0] = (byte)b;
+        write(singleByteBuffer, 0, 1);
+    }
+
+    public void write(byte[] buf) throws IOException {
+        write(buf, 0, buf.length);
+    }
+
+    public void write(byte[] buf, int off, int siz) throws IOException {
+        checkClosed();
+        try {
+            writeToCopy(buf, off, siz);
+        } catch(SQLException se) {
+            IOException ioe = new IOException("Write to copy failed.");
+            ioe.initCause(se);
+            throw ioe;
+        }
+    }
+
+    private void checkClosed() throws IOException {
+        if (op == null) {
+            throw new IOException(GT.tr("This copy stream is closed."));
+        }
+    }
+
+    public void close() throws IOException {
+        // Don't complain about a double close.
+        if (op == null)
+            return;
+
+        try{
+            endCopy();
+        } catch(SQLException se) {
+            IOException ioe = new IOException("Ending write to copy failed.");
+            ioe.initCause(se);
+            throw ioe;
+        }
+        op = null;
+    }
+
+    public void flush() throws IOException {
+        try {
+            op.writeToCopy(copyBuffer, 0, at);
+            at = 0;
+            op.flushCopy();
+        } catch (SQLException e) {
+            IOException ioe = new IOException("Unable to flush stream");
+            ioe.initCause(e);
+            throw ioe;
+        }
+    }
+
+    public void writeToCopy(byte[] buf, int off, int siz) throws SQLException {
+        if(at > 0 && siz > copyBuffer.length - at) { // would not fit into rest of our buf, so flush buf
+            op.writeToCopy(copyBuffer, 0, at);
+            at = 0;
+        }
+        if(siz > copyBuffer.length) { // would still not fit into buf, so just pass it through
+            op.writeToCopy(buf, off, siz);
+        } else { // fits into our buf, so save it there
+            System.arraycopy(buf, off, copyBuffer, at, siz);
+            at += siz;
+        }
+    }
+
+    public int getFormat() {
+        return op.getFormat();
+    }
+
+    public int getFieldFormat(int field) {
+        return op.getFieldFormat(field);
+    }
+
+    public void cancelCopy() throws SQLException {
+        op.cancelCopy();
+    }
+
+    public int getFieldCount() {
+        return op.getFieldCount();
+    }
+
+    public boolean isActive() {
+        return op.isActive();
+    }
+
+    public void flushCopy() throws SQLException {
+        op.flushCopy();
+    }
+
+    public long endCopy() throws SQLException {
+        if(at > 0) {
+            op.writeToCopy(copyBuffer, 0, at);
+        }
+        op.endCopy();
+        return getHandledRowCount();
+    }
+
+    public long getHandledRowCount() {
+        return op.getHandledRowCount();
+    }
+
+}

=== added directory 'src/org/postgresql/driver/core'
=== added file 'src/org/postgresql/driver/core/BaseConnection.java'
--- src/org/postgresql/driver/core/BaseConnection.java	1970-01-01 00:00:00 +0000
+++ src/org/postgresql/driver/core/BaseConnection.java	2011-08-30 20:30:24 +0000
@@ -0,0 +1,163 @@
+/*****************************************************************************
+ * Copyright (C) 2008 EnterpriseDB Corporation.
+ * Copyright (C) 2011 Stado Global Development Group.
+ *
+ * This file is part of Stado.
+ *
+ * Stado is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Stado is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Stado.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * You can find Stado at http://www.stado.us
+ *
+ ****************************************************************************/
+package org.postgresql.driver.core;
+
+import java.sql.*;
+
+import org.postgresql.driver.PGConnection;
+import org.postgresql.driver.jdbc2.TimestampUtils;
+
+/**
+ * Driver-internal connection interface. Application code should not use
+ * this interface.
+ */
+public interface BaseConnection extends PGConnection, Connection
+{
+    /**
+     * Cancel the current query executing on this connection.
+     *
+     * @throws SQLException if something goes wrong.
+     */
+    public void cancelQuery() throws SQLException;
+
+    /**
+     * Execute a SQL query that returns a single resultset.
+     * Never causes a new transaction to be started regardless of the autocommit setting.
+     *
+     * @param s the query to execute
+     * @return the (non-null) returned resultset
+     * @throws SQLException if something goes wrong.
+     */
+    public ResultSet execSQLQuery(String s) throws SQLException;
+
+    public ResultSet execSQLQuery(String s, int resultSetType, int resultSetConcurrency) throws SQLException;
+
+    /**
+     * Execute a SQL query that does not return results.
+     * Never causes a new transaction to be started regardless of the autocommit setting.
+     *
+     * @param s the query to execute
+     * @throws SQLException if something goes wrong.
+     */
+    public void execSQLUpdate(String s) throws SQLException;
+
+    /**
+     * Get the QueryExecutor implementation for this connection.
+     *
+     * @return the (non-null) executor
+     */
+    public QueryExecutor getQueryExecutor();
+
+    /**
+     * Construct and return an appropriate object for the given
+     * type and value. This only considers the types registered via
+     * {@link org.postgresql.driver.PGConnection#addDataType(String,Class)} and
+     * {@link org.postgresql.driver.PGConnection#addDataType(String,String)}.
+     *<p>
+     * If no class is registered as handling the given type, then a generic
+     * {@link org.postgresql.driver.util.PGobject} instance is returned.
+     *
+     * @param type the backend typename
+     * @param value the type-specific string representation of the value
+     * @return an appropriate object; never null.
+     * @throws SQLException if something goes wrong
+     */
+    public Object getObject(String type, String value) throws SQLException;
+
+    public Encoding getEncoding() throws SQLException;
+
+    public TypeInfo getTypeInfo();
+
+    /**
+     * Check if we should use driver behaviour introduced in a particular
+     * driver version. This defaults to behaving as the actual driver's version
+     * but can be overridden by the "compatible" URL parameter.
+     *
+     * @param ver the driver version to check
+     * @return true if the driver's behavioural version is at least "ver".
+     * @throws SQLException if something goes wrong
+     */
+    public boolean haveMinimumCompatibleVersion(String ver);
+
+    /**
+     * Check if we have at least a particular server version.
+     *
+     * @param ver the server version to check
+     * @return true if the server version is at least "ver".
+     * @throws SQLException if something goes wrong
+     */
+    public boolean haveMinimumServerVersion(String ver);
+
+    /**
+     * Encode a string using the database's client_encoding
+     * (usually UNICODE, but can vary on older server versions).
+     * This is used when constructing synthetic resultsets (for
+     * example, in metadata methods).
+     *
+     * @param str the string to encode
+     * @return an encoded representation of the string
+     * @throws SQLException if something goes wrong.
+     */
+    public byte[] encodeString(String str) throws SQLException;
+
+    /**
+     * Escapes a string for use as string-literal within an SQL command. The
+     * method chooses the applicable escaping rules based on the value of
+     * {@link #getStandardConformingStrings()}.
+     * 
+     * @param str a string value
+     * @return the escaped representation of the string
+     * @throws SQLException if the string contains a <tt>\0</tt> character
+     */
+    public String escapeString(String str) throws SQLException;
+
+    /**
+     * Returns whether the server treats string-literals according to the SQL
+     * standard or if it uses traditional PostgreSQL escaping rules. Versions
+     * up to 8.1 always treated backslashes as escape characters in
+     * string-literals. Since 8.2, this depends on the value of the
+     * <tt>standard_conforming_strings<tt> server variable.
+     * 
+     * @return true if the server treats string literals according to the SQL
+     *   standard
+     * 
+     * @see ProtocolConnection#getStandardConformingStrings()
+     */
+    public boolean getStandardConformingStrings();
+
+    // Ew. Quick hack to give access to the connection-specific utils implementation.
+    public TimestampUtils getTimestampUtils();
+
+    // Get the per-connection logger.
+    public Logger getLogger();
+
+    // Get the bind-string-as-varchar config flag
+    public boolean getStringVarcharFlag();
+
+    /**
+     * Get the current transaction state of this connection.
+     * 
+     * @return a ProtocolConnection.TRANSACTION_* constant.
+     */
+    public int getTransactionState();
+}

=== added file 'src/org/postgresql/driver/core/BaseResultSet.java'
--- src/org/postgresql/driver/core/BaseResultSet.java	1970-01-01 00:00:00 +0000
+++ src/org/postgresql/driver/core/BaseResultSet.java	2011-08-30 20:30:24 +0000
@@ -0,0 +1,44 @@
+/*****************************************************************************
+ * Copyright (C) 2008 EnterpriseDB Corporation.
+ * Copyright (C) 2011 Stado Global Development Group.
+ *
+ * This file is part of Stado.
+ *
+ * Stado is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Stado is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Stado.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * You can find Stado at http://www.stado.us
+ *
+ ****************************************************************************/
+package org.postgresql.driver.core;
+
+import java.sql.*;
+
+/**
+ * Driver-internal resultset interface. Application code should not use
+ * this interface.
+ */
+public interface BaseResultSet extends ResultSet
+{
+    /**
+     * Return a sanitized numeric string for a column. This handles
+     * "money" representations, stripping $ and () as appropriate.
+     *
+     * @param col the 1-based column to retrieve
+     * @return the sanitized string
+     * @throws SQLException if something goes wrong
+     */
+    public String getFixedString(int col) throws SQLException;
+
+    public Array createArray(int col) throws SQLException;
+}

=== added file 'src/org/postgresql/driver/core/BaseStatement.java'
--- src/org/postgresql/driver/core/BaseStatement.java	1970-01-01 00:00:00 +0000
+++ src/org/postgresql/driver/core/BaseStatement.java	2011-08-30 20:30:24 +0000
@@ -0,0 +1,76 @@
+/*****************************************************************************
+ * Copyright (C) 2008 EnterpriseDB Corporation.
+ * Copyright (C) 2011 Stado Global Development Group.
+ *
+ * This file is part of Stado.
+ *
+ * Stado is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Stado is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Stado.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * You can find Stado at http://www.stado.us
+ *
+ ****************************************************************************/
+package org.postgresql.driver.core;
+
+import org.postgresql.driver.PGStatement;
+
+import java.sql.*;
+import java.util.Vector;
+
+/**
+ * Driver-internal statement interface. Application code should not use
+ * this interface.
+ */
+public interface BaseStatement extends PGStatement, Statement
+{
+    /**
+     * Create a synthetic resultset from data provided by the driver.
+     *
+     * @param fields the column metadata for the resultset
+     * @param tuples the resultset data
+     * @return the new ResultSet
+     * @throws SQLException if something goes wrong
+     */
+    public ResultSet createDriverResultSet(Field[] fields, Vector tuples) throws SQLException;
+
+    /**
+     * Create a resultset from data retrieved from the server.
+     *
+     * @param originalQuery the query that generated this resultset; used when dealing with updateable resultsets
+     * @param fields the column metadata for the resultset
+     * @param tuples the resultset data
+     * @param cursor the cursor to use to retrieve more data from the server; if null, no additional data is present.
+     * @return the new ResultSet
+     * @throws SQLException if something goes wrong
+     */
+    public ResultSet createResultSet(Query originalQuery, Field[] fields, Vector tuples, ResultCursor cursor) throws SQLException;
+
+    /**
+     * Execute a query, passing additional query flags.
+     *
+     * @param p_sql the query to execute
+     * @param flags additional {@link QueryExecutor} flags for execution; these
+     *  are bitwise-ORed into the default flags.
+     * @throws SQLException if something goes wrong.
+     */
+    public boolean executeWithFlags(String p_sql, int flags) throws SQLException;
+
+    /**
+     * Execute a prepared query, passing additional query flags.
+     *
+     * @param flags additional {@link QueryExecutor} flags for execution; these
+     *  are bitwise-ORed into the default flags.
+     * @throws SQLException if something goes wrong.
+     */
+    public boolean executeWithFlags(int flags) throws SQLException;
+}

=== added file 'src/org/postgresql/driver/core/ConnectionFactory.java'
--- src/org/postgresql/driver/core/ConnectionFactory.java	1970-01-01 00:00:00 +0000
+++ src/org/postgresql/driver/core/ConnectionFactory.java	2011-08-30 20:30:24 +0000
@@ -0,0 +1,104 @@
+/*****************************************************************************
+ * Copyright (C) 2008 EnterpriseDB Corporation.
+ * Copyright (C) 2011 Stado Global Development Group.
+ *
+ * This file is part of Stado.
+ *
+ * Stado is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Stado is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Stado.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * You can find Stado at http://www.stado.us
+ *
+ ****************************************************************************/
+package org.postgresql.driver.core;
+
+import java.util.Properties;
+import java.sql.SQLException;
+
+import org.postgresql.driver.util.GT;
+import org.postgresql.driver.util.PSQLException;
+import org.postgresql.driver.util.PSQLState;
+
+/**
+ * Handles protocol-specific connection setup.
+ *
+ * @author Oliver Jowett ([e-mail])
+ */
+public abstract class ConnectionFactory {
+    /**
+     * Protocol version to implementation instance map.
+     * If no protocol version is specified, instances are
+     * tried in order until an exception is thrown or a non-null
+     * connection is returned.
+     */
+    private static final Object[][] versions = {
+                { "3", new org.postgresql.driver.core.v3.ConnectionFactoryImpl() },
+                { "2", new org.postgresql.driver.core.v2.ConnectionFactoryImpl() },
+            };
+
+    /**
+     * Establishes and initializes a new connection.
+     *<p>
+     * If the "protocolVersion" property is specified, only that protocol
+     * version is tried. Otherwise, all protocols are tried in order, falling
+     * back to older protocols as necessary.
+     *<p>
+     * Currently, protocol versions 3 (7.4+) and 2 (pre-7.4) are supported.
+     *
+     * @param host the host to connect to
+     * @param port the port to connect to
+     * @param user the username to authenticate with; may not be null.
+     * @param database the database on the server to connect to; may not be null.
+     * @param info extra properties controlling the connection;
+     *    notably, "password" if present supplies the password to authenticate with.
+     * @param logger the logger to use for this connection
+     * @return the new, initialized, connection
+     * @throws SQLException if the connection could not be established.
+     */
+    public static ProtocolConnection openConnection(String host, int port, String user, String database, Properties info, Logger logger) throws SQLException {
+        String protoName = info.getProperty("protocolVersion");
+
+        for (int i = 0; i < versions.length; ++i)
+        {
+            String versionProtoName = (String) versions[i][0];
+            if (protoName != null && !protoName.equals(versionProtoName))
+                continue;
+
+            ConnectionFactory factory = (ConnectionFactory) versions[i][1];
+            ProtocolConnection connection = factory.openConnectionImpl(host, port, user, database, info, logger);
+            if (connection != null)
+                return connection;
+        }
+
+        throw new PSQLException(GT.tr("A connection could not be made using the requested protocol {0}.", protoName),
+                                PSQLState.CONNECTION_UNABLE_TO_CONNECT);
+    }
+
+    /**
+     * Implementation of {@link #openConnection} for a particular protocol version.
+     * Implemented by subclasses of {@link ConnectionFactory}.
+     *
+     * @param host the host to connect to
+     * @param port the port to connect to
+     * @param user the username to authenticate with; may not be null.
+     * @param database the database on the server to connect to; may not be null.
+     * @param info extra properties controlling the connection;
+     *    notably, "password" if present supplies the password to authenticate with.
+     * @param logger the logger to use for this connection
+     * @return the new, initialized, connection, or <code>null</code> if this protocol
+     *    version is not supported by the server.
+     * @throws SQLException if the connection could not be established for a reason other
+     *    than protocol version incompatibility.
+     */
+    public abstract ProtocolConnection openConnectionImpl(String host, int port, String user, String database, Properties info, Logger logger) throws SQLException;
+}

=== added file 'src/org/postgresql/driver/core/Encoding.java'
--- src/org/postgresql/driver/core/Encoding.java	1970-01-01 00:00:00 +0000
+++ src/org/postgresql/driver/core/Encoding.java	2011-08-30 20:30:24 +0000
@@ -0,0 +1,306 @@
+/*****************************************************************************
+ * Copyright (C) 2008 EnterpriseDB Corporation.
+ * Copyright (C) 2011 Stado Global Development Group.
+ *
+ * This file is part of Stado.
+ *
+ * Stado is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Stado is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Stado.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * You can find Stado at http://www.stado.us
+ *
+ ****************************************************************************/
+package org.postgresql.driver.core;
+
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.Reader;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.io.IOException;
+import java.util.HashMap;
+
+/**
+ * Representation of a particular character encoding.
+ */
+public class Encoding
+{
+    private static final Encoding DEFAULT_ENCODING = new Encoding(null);
+
+    /*
+     * Preferred JVM encodings for backend encodings.
+     */
+    private static final HashMap encodings = new HashMap();
+
+    static {
+        //Note: this list should match the set of supported server
+        // encodings found in backend/util/mb/encnames.c
+        encodings.put("SQL_ASCII", new String[] { "ASCII", "us-ascii" });
+        encodings.put("UNICODE", new String[] { "UTF-8", "UTF8" });
+        encodings.put("UTF8", new String[] { "UTF-8", "UTF8" }); // 8.1's canonical name for UNICODE changed.
+        encodings.put("LATIN1", new String[] { "ISO8859_1" });
+        encodings.put("LATIN2", new String[] { "ISO8859_2" });
+        encodings.put("LATIN3", new String[] { "ISO8859_3" });
+        encodings.put("LATIN4", new String[] { "ISO8859_4" });
+        encodings.put("ISO_8859_5", new String[] { "ISO8859_5" });
+        encodings.put("ISO_8859_6", new String[] { "ISO8859_6" });
+        encodings.put("ISO_8859_7", new String[] { "ISO8859_7" });
+        encodings.put("ISO_8859_8", new String[] { "ISO8859_8" });
+        encodings.put("LATIN5", new String[] { "ISO8859_9" });
+        encodings.put("LATIN7", new String[] { "ISO8859_13" });
+        encodings.put("LATIN9", new String[] { "ISO8859_15_FDIS" });
+        encodings.put("EUC_JP", new String[] { "EUC_JP" });
+        encodings.put("EUC_CN", new String[] { "EUC_CN" });
+        encodings.put("EUC_KR", new String[] { "EUC_KR" });
+        encodings.put("JOHAB", new String[] { "Johab" });
+        encodings.put("EUC_TW", new String[] { "EUC_TW" });
+        encodings.put("SJIS", new String[] { "MS932", "SJIS" });
+        encodings.put("BIG5", new String[] { "Big5", "MS950", "Cp950" });
+        encodings.put("GBK", new String[] { "GBK", "MS936" });
+        encodings.put("UHC", new String[] { "MS949", "Cp949", "Cp949C" });
+        encodings.put("TCVN", new String[] { "Cp1258" });
+        encodings.put("WIN1256", new String[] { "Cp1256" });
+        encodings.put("WIN1250", new String[] { "Cp1250" });
+        encodings.put("WIN874", new String[] { "MS874", "Cp874" });
+        encodings.put("WIN", new String[] { "Cp1251" });
+        encodings.put("ALT", new String[] { "Cp866" });
+        // We prefer KOI8-U, since it is a superset of KOI8-R.
+        encodings.put("KOI8", new String[] { "KOI8_U", "KOI8_R" });
+        // If the database isn't encoding-aware then we can't have
+        // any preferred encodings.
+        encodings.put("UNKNOWN", new String[0]);
+        // The following encodings do not have a java equivalent
+        encodings.put("MULE_INTERNAL", new String[0]);
+        encodings.put("LATIN6", new String[0]);
+        encodings.put("LATIN8", new String[0]);
+        encodings.put("LATIN10", new String[0]);
+    }
+
+    private final String encoding;
+    private final boolean fastASCIINumbers;
+
+    protected Encoding(String encoding)
+    {
+        this.encoding = encoding;
+        fastASCIINumbers = testAsciiNumbers();
+    }
+    
+    /**
+     * Returns true if this encoding has characters
+     * '-' and '0'..'9' in exactly same posision as ascii.
+     *  
+     * @return true if the bytes can be scanned directly for ascii numbers.
+     */
+    public boolean hasAsciiNumbers() {
+        return fastASCIINumbers;
+    }
+
+    /**
+     * Construct an Encoding for a given JVM encoding.
+     * 
+     * @param jvmEncoding the name of the JVM encoding
+     * @return an Encoding instance for the specified encoding,
+     *   or an Encoding instance for the default JVM encoding if the
+     *   specified encoding is unavailable.
+     */
+    public static Encoding getJVMEncoding(String jvmEncoding) {
+        if (isAvailable(jvmEncoding))
+        {
+            if (jvmEncoding.equals("UTF-8") || jvmEncoding.equals("UTF8"))
+                return new UTF8Encoding(jvmEncoding);
+            else
+                return new Encoding(jvmEncoding);
+        }
+        else
+            return defaultEncoding();
+    }
+
+    /**
+     * Construct an Encoding for a given database encoding.
+     * 
+     * @param databaseEncoding the name of the database encoding
+     * @return an Encoding instance for the specified encoding,
+     *   or an Encoding instance for the default JVM encoding if the
+     *   specified encoding is unavailable.
+     */
+    public static Encoding getDatabaseEncoding(String databaseEncoding)
+    {
+        // If the backend encoding is known and there is a suitable
+        // encoding in the JVM we use that. Otherwise we fall back
+        // to the default encoding of the JVM.
+
+        String[] candidates = (String[]) encodings.get(databaseEncoding);
+        if (candidates != null)
+        {
+            for (int i = 0; i < candidates.length; i++)
+            {
+                if (isAvailable(candidates[i]))
+                {
+                    return new Encoding(candidates[i]);
+                }
+            }
+        }
+
+        // Try the encoding name directly -- maybe the charset has been
+        // provided by the user.
+        if (isAvailable(databaseEncoding))
+            return new Encoding(databaseEncoding);
+
+        // Fall back to default JVM encoding.
+        return defaultEncoding();
+    }
+
+    /**
+     * Get the name of the (JVM) encoding used.
+     *
+     * @return the JVM encoding name used by this instance.
+     */
+    public String name()
+    {
+        return encoding;
+    }
+
+    /**
+     * Encode a string to an array of bytes.
+     *
+     * @param s the string to encode
+     * @return a bytearray containing the encoded string
+     * @throws IOException if something goes wrong
+     */
+    public byte[] encode(String s) throws IOException
+    {
+        if (s == null)
+            return null;
+
+        if (encoding == null)
+            return s.getBytes();
+
+        return s.getBytes(encoding);
+    }
+
+    /**
+     * Decode an array of bytes into a string.
+     * 
+     * @param encodedString a bytearray containing the encoded string  the string to encod
+     * @param offset the offset in <code>encodedString</code> of the first byte of the encoded representation
+     * @param length the length, in bytes, of the encoded representation
+     * @return the decoded string
+     * @throws IOException if something goes wrong
+     */
+    public String decode(byte[] encodedString, int offset, int length) throws IOException
+    {
+        if (encoding == null)
+            return new String(encodedString, offset, length);
+
+        return new String(encodedString, offset, length, encoding);
+    }
+
+    /**
+     * Decode an array of bytes into a string.
+     *
+     * @param encodedString a bytearray containing the encoded string  the string to encod
+     * @return the decoded string
+     * @throws IOException if something goes wrong
+     */
+    public String decode(byte[] encodedString) throws IOException
+    {
+        return decode(encodedString, 0, encodedString.length);
+    }
+
+    /**
+     * Get a Reader that decodes the given InputStream using this encoding.
+     *
+     * @param in the underlying stream to decode from
+     * @return a non-null Reader implementation.
+     * @throws IOException if something goes wrong
+     */
+    public Reader getDecodingReader(InputStream in) throws IOException
+    {
+        if (encoding == null)
+            return new InputStreamReader(in);
+
+        return new InputStreamReader(in, encoding);
+    }
+
+    /**
+     * Get a Writer that encodes to the given OutputStream using this encoding.
+     *
+     * @param out the underlying stream to encode to
+     * @return a non-null Writer implementation.
+     * @throws IOException if something goes wrong
+     */
+    public Writer getEncodingWriter(OutputStream out) throws IOException
+    {
+        if (encoding == null)
+            return new OutputStreamWriter(out);
+
+        return new OutputStreamWriter(out, encoding);
+    }
+
+    /**
+     * Get an Encoding using the default encoding for the JVM.
+     * @return an Encoding instance
+     */
+    public static Encoding defaultEncoding()
+    {
+        return DEFAULT_ENCODING;
+    }
+
+    /**
+     * Test if an encoding is available in the JVM.
+     *
+     * @param encodingName the JVM encoding name to test
+     * @return true iff the encoding is supported
+     */
+    private static boolean isAvailable(String encodingName)
+    {
+        try
+        {
+            "DUMMY".getBytes(encodingName);
+            return true;
+        }
+        catch (java.io.UnsupportedEncodingException e)
+        {
+            return false;
+        }
+    }
+
+    public String toString() {
+        return (encoding == null ? "<default JVM encoding>" : encoding);
+    }
+    
+    /**
+     * Checks weather this encoding is compatible with ASCII for the number
+     * characters '-' and '0'..'9'. Where compatible means that they are encoded
+     * with exactly same values. 
+     * 
+     * @return If faster ASCII number parsing can be used with this encoding.
+     */
+    private boolean testAsciiNumbers() {
+        // TODO: test all postgres supported encoding to see if there are
+        // any which do _not_ have ascii numbers in same location
+        // at least all the encoding listed in the encodings hashmap have
+        // working ascii numbers
+	try {
+	    String test = "-0123456789";
+	    byte[] bytes = encode(test);
+	    String res = new String(bytes, "US-ASCII");
+	    return test.equals(res);
+	} catch (java.io.UnsupportedEncodingException e) {
+	    return false;
+	} catch (IOException e) {
+	    return false;
+	}
+    }
+}

=== added file 'src/org/postgresql/driver/core/Field.java'
--- src/org/postgresql/driver/core/Field.java	1970-01-01 00:00:00 +0000
+++ src/org/postgresql/driver/core/Field.java	2011-08-30 20:30:24 +0000
@@ -0,0 +1,275 @@
+/*****************************************************************************
+ * Copyright (C) 2008 EnterpriseDB Corporation.
+ * Copyright (C) 2011 Stado Global Development Group.
+ *
+ * This file is part of Stado.
+ *
+ * Stado is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Stado is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Stado.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * You can find Stado at http://www.stado.us
+ *
+ ****************************************************************************/
+package org.postgresql.driver.core;
+
+import java.sql.*;
+
+/*
+ */
+public class Field
+{
+    //The V3 protocol defines two constants for the format of data
+    public static final int TEXT_FORMAT = 0;
+    public static final int BINARY_FORMAT = 1;
+
+    private final int length;    // Internal Length of this field
+    private final int oid;        // OID of the type
+    private final int mod;        // type modifier of this field
+    private final String columnLabel; // Column label
+    private String columnName;        // Column name; null if undetermined
+    private Integer nullable;         // Is this column nullable? null if undetermined.
+    private Boolean autoIncrement;   // Is this column automatically numbered?
+
+    private int format = TEXT_FORMAT;   // In the V3 protocol each field has a format
+    // 0 = text, 1 = binary
+    // In the V2 protocol all fields in a
+    // binary cursor are binary and all
+    // others are text
+
+    private final int tableOid; // OID of table ( zero if no table )
+    private final int positionInTable;
+
+    // cache-fields
+
+    /*
+     * Construct a field based on the information fed to it.
+     *
+     * @param name the name (column name and label) of the field
+     * @param oid the OID of the field
+     * @param len the length of the field
+     */
+    public Field(String name, int oid, int length, int mod)
+    {
+        this(name, name, oid, length, mod, 0, 0);
+    }
+
+    /*
+     * Constructor without mod parameter.
+     *
+     * @param name the name (column name and label) of the field
+     * @param oid the OID of the field
+     * @param len the length of the field
+     */
+    public Field(String name, int oid)
+    {
+        this(name, oid, 0, -1);
+    }
+
+    /*
+     * Construct a field based on the information fed to it.
+     *
+     * @param columnLabel the column label of the field
+     * @param columnName the column label the name of the field
+     * @param oid the OID of the field
+     * @param length the length of the field
+     * @param tableOid the OID of the columns' table
+     * @param positionInTable the position of column in the table (first column is 1, second column is 2, etc...)
+     */
+    public Field(String columnLabel, String columnName, int oid, int length, int mod, int tableOid, int positionInTable)
+    {
+        this.columnLabel = columnLabel;
+        this.columnName = columnName;
+        this.oid = oid;
+        this.length = length;
+        this.mod = mod;
+        this.tableOid = tableOid;
+        this.positionInTable = positionInTable;
+    }
+
+    /*
+     * @return the oid of this Field's data type
+     */
+    public int getOID()
+    {
+        return oid;
+    }
+
+    /*
+     * @return the mod of this Field's data type
+     */
+    public int getMod()
+    {
+        return mod;
+    }
+
+    /*
+     * @return the column label of this Field's data type
+     */
+    public String getColumnLabel()
+    {
+        return columnLabel;
+    }
+
+    /*
+     * @return the length of this Field's data type
+     */
+    public int getLength()
+    {
+        return length;
+    }
+
+    /*
+     * @return the format of this Field's data (text=0, binary=1)
+     */
+    public int getFormat()
+    {
+        return format;
+    }
+
+    /*
+     * @param format the format of this Field's data (text=0, binary=1)
+     */
+    public void setFormat(int format)
+    {
+        this.format = format;
+    }
+
+    /*
+     * @return the columns' table oid, zero if no oid available
+     */
+    public int getTableOid()
+    {
+        return tableOid;
+    }
+
+    public int getPositionInTable()
+    {
+        return positionInTable;
+    }
+
+    public int getNullable(Connection con) throws SQLException
+    {
+        if (nullable != null)
+            return nullable.intValue();
+
+        if (tableOid == 0 || positionInTable == 0)
+        {
+            nullable = new Integer(ResultSetMetaData.columnNullableUnknown);
+            return nullable.intValue();
+        }
+
+        ResultSet res = null;
+        PreparedStatement ps = null;
+        try
+        {
+            ps = con.prepareStatement("SELECT attnotnull FROM pg_catalog.pg_attribute WHERE attrelid = ? AND attnum = ?;");
+            ps.setInt(1, tableOid);
+            ps.setInt(2, positionInTable);
+            res = ps.executeQuery();
+
+            int nullResult = ResultSetMetaData.columnNullableUnknown;
+            if (res.next())
+                nullResult = res.getBoolean(1) ? ResultSetMetaData.columnNoNulls : ResultSetMetaData.columnNullable;
+
+            nullable = new Integer(nullResult);
+            return nullResult;
+        }
+        finally
+        {
+            if (res != null)
+                res.close();
+            if (ps != null)
+                ps.close();
+        }
+    }
+
+    public boolean getAutoIncrement(Connection con) throws SQLException
+    {
+        if (autoIncrement != null)
+            return autoIncrement.booleanValue();
+
+        if (tableOid == 0 || positionInTable == 0)
+        {
+            autoIncrement = Boolean.FALSE;
+            return autoIncrement.booleanValue();
+        }
+
+        ResultSet res = null;
+        PreparedStatement ps = null;
+        try
+        {
+            final String sql = "SELECT 1 "
+                                + " FROM pg_catalog.pg_attrdef "
+                                + " WHERE adrelid = ? AND adnum = ? "
+                                + "  AND pg_catalog.pg_get_expr(adbin, adrelid) "
+                                + "      LIKE '%nextval(%'";
+
+            ps = con.prepareStatement(sql);
+
+            ps.setInt(1, tableOid);
+            ps.setInt(2, positionInTable);
+            res = ps.executeQuery();
+
+            if (res.next())
+            {
+                autoIncrement = Boolean.TRUE;
+            }
+            else
+            {
+                autoIncrement = Boolean.FALSE;
+            }
+            return autoIncrement.booleanValue();
+
+        }
+        finally
+        {
+            if (res != null)
+                res.close();
+            if (ps != null)
+                ps.close();
+        }
+    }
+
+    public String getColumnName(Connection con) throws SQLException
+    {
+        if (columnName != null)
+            return columnName;
+
+        columnName = "";
+        if (tableOid == 0 || positionInTable == 0)
+        {
+            return columnName;
+        }
+
+        ResultSet res = null;
+        PreparedStatement ps = null;
+        try
+        {
+            ps = con.prepareStatement("SELECT attname FROM pg_catalog.pg_attribute WHERE attrelid = ? AND attnum = ?");
+            ps.setInt(1, tableOid);
+            ps.setInt(2, positionInTable);
+            res = ps.executeQuery();
+            if (res.next())
+                columnName = res.getString(1);
+
+            return columnName;
+        }
+        finally
+        {
+            if (res != null)
+                res.close();
+            if (ps != null)
+                ps.close();
+        }
+    }
+}

=== added file 'src/org/postgresql/driver/core/Logger.java'
--- src/org/postgresql/driver/core/Logger.java	1970-01-01 00:00:00 +0000
+++ src/org/postgresql/driver/core/Logger.java	2011-08-30 20:30:24 +0000
@@ -0,0 +1,110 @@
+/*****************************************************************************
+ * Copyright (C) 2008 EnterpriseDB Corporation.
+ * Copyright (C) 2011 Stado Global Development Group.
+ *
+ * This file is part of Stado.
+ *
+ * Stado is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Stado is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Stado.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * You can find Stado at http://www.stado.us
+ *
+ ****************************************************************************/
+package org.postgresql.driver.core;
+
+import java.text.SimpleDateFormat;
+import java.text.FieldPosition;
+import java.sql.DriverManager;
+import java.io.PrintWriter;
+import java.util.Date;
+
+import org.postgresql.driver.Driver;
+
+/**
+ * Poor man's logging infrastructure. This just deals with maintaining a per-
+ * connection ID and log level, and timestamping output.
+ */
+public final class Logger {
+    // For brevity we only log the time, not date or timezone (the main reason
+    // for the timestamp is to see delays etc. between log lines, not to pin
+    // down an instant in time)
+    private final SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss.SSS ");
+    private final FieldPosition dummyPosition = new FieldPosition(0);
+    private final StringBuffer buffer = new StringBuffer();
+    private final String connectionIDString;
+
+    private int level = 0;
+
+    public Logger() {
+        connectionIDString = "(driver) ";
+    }
+
+    public Logger(int connectionID) {
+        connectionIDString = "(" + connectionID + ") ";
+    }
+
+    public void setLogLevel(int level) {
+        this.level = level;
+    }
+
+    public int getLogLevel() {
+        return level;
+    }
+
+    public boolean logDebug() {
+        return level >= Driver.DEBUG;
+    }
+
+    public boolean logInfo() {
+        return level >= Driver.INFO;
+    }
+
+    public void debug(String str) {
+        debug(str, null);
+    }
+
+    public void debug(String str, Throwable t) {
+        if (logDebug())
+            log(str, t);
+    }
+
+    public void info(String str) {
+        info(str, null);
+    }
+
+    public void info(String str, Throwable t) {
+        if (logInfo())
+            log(str, t);
+    }
+
+    public void log(String str, Throwable t) {
+        PrintWriter writer = DriverManager.getLogWriter();
+        if (writer == null)
+            return;
+
+        synchronized (this) {
+            buffer.setLength(0);
+            dateFormat.format(new Date(), buffer, dummyPosition);
+            buffer.append(connectionIDString);
+            buffer.append(str);
+            
+            // synchronize to ensure that the exception (if any) does
+            // not get split up from the corresponding log message
+            synchronized (writer) {
+                writer.println(buffer.toString());        
+                if (t != null)
+                    t.printStackTrace(writer);
+            }
+        }
+    }
+}

=== added file 'src/org/postgresql/driver/core/Notification.java'
--- src/org/postgresql/driver/core/Notification.java	1970-01-01 00:00:00 +0000
+++ src/org/postgresql/driver/core/Notification.java	2011-08-30 20:30:24 +0000
@@ -0,0 +1,67 @@
+/*****************************************************************************
+ * Copyright (C) 2008 EnterpriseDB Corporation.
+ * Copyright (C) 2011 Stado Global Development Group.
+ *
+ * This file is part of Stado.
+ *
+ * Stado is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Stado is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Stado.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * You can find Stado at http://www.stado.us
+ *
+ ****************************************************************************/
+package org.postgresql.driver.core;
+
+import org.postgresql.driver.PGNotification;
+
+public class Notification implements PGNotification
+{
+    public Notification(String p_name, int p_pid)
+    {
+        this(p_name, p_pid, "");
+    }
+
+    public Notification(String p_name, int p_pid, String p_parameter)
+    {
+        m_name = p_name;
+        m_pid = p_pid;
+        m_parameter = p_parameter;
+    }
+
+    /*
+     * Returns name of this notification
+     */
+    public String getName()
+    {
+        return m_name;
+    }
+
+    /*
+     * Returns the process id of the backend process making this notification
+     */
+    public int getPID()
+    {
+        return m_pid;
+    }
+
+    public String getParameter()
+    {
+        return m_parameter;
+    }
+
+    private String m_name;
+    private String m_parameter;
+    private int m_pid;
+
+}
+

=== added file 'src/org/postgresql/driver/core/Oid.java'
--- src/org/postgresql/driver/core/Oid.java	1970-01-01 00:00:00 +0000
+++ src/org/postgresql/driver/core/Oid.java	2011-08-30 20:30:24 +0000
@@ -0,0 +1,83 @@
+/*****************************************************************************
+ * Copyright (C) 2008 EnterpriseDB Corporation.
+ * Copyright (C) 2011 Stado Global Development Group.
+ *
+ * This file is part of Stado.
+ *
+ * Stado is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Stado is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Stado.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * You can find Stado at http://www.stado.us
+ *
+ ****************************************************************************/
+package org.postgresql.driver.core;
+
+/**
+ * Provides constants for well-known backend OIDs for the types we commonly
+ * use.
+ */
+public class Oid {
+    public static final int UNSPECIFIED = 0;
+    public static final int INT2 = 21;
+    public static final int INT2_ARRAY = 1005;
+    public static final int INT4 = 23;
+    public static final int INT4_ARRAY = 1007;
+    public static final int INT8 = 20;
+    public static final int INT8_ARRAY = 1016;
+    public static final int TEXT = 25;
+    public static final int TEXT_ARRAY = 1009;
+    public static final int NUMERIC = 1700;
+    public static final int NUMERIC_ARRAY = 1231;
+    public static final int FLOAT4 = 700;
+    public static final int FLOAT4_ARRAY = 1021;
+    public static final int FLOAT8 = 701;
+    public static final int FLOAT8_ARRAY = 1022;
+    public static final int BOOL = 16;
+    public static final int BOOL_ARRAY = 1000;
+    public static final int DATE = 1082;
+    public static final int DATE_ARRAY = 1182;
+    public static final int TIME = 1083;
+    public static final int TIME_ARRAY = 1183;
+    public static final int TIMETZ = 1266;
+    public static final int TIMETZ_ARRAY = 1270;
+    public static final int TIMESTAMP = 1114;
+    public static final int TIMESTAMP_ARRAY = 1115;
+    public static final int TIMESTAMPTZ = 1184;
+    public static final int TIMESTAMPTZ_ARRAY = 1185;
+    public static final int BYTEA = 17;
+    public static final int BYTEA_ARRAY = 1001;
+    public static final int VARCHAR = 1043;
+    public static final int VARCHAR_ARRAY = 1015;
+    public static final int OID = 26;
+    public static final int OID_ARRAY = 1028;
+    public static final int BPCHAR = 1042;
+    public static final int BPCHAR_ARRAY = 1014;
+    public static final int MONEY = 790;
+    public static final int MONEY_ARRAY = 791;
+    public static final int NAME = 19;
+    public static final int NAME_ARRAY = 1003;
+    public static final int BIT = 1560;
+    public static final int BIT_ARRAY = 1561;
+    public static final int VOID = 2278;
+    public static final int INTERVAL = 1186;
+    public static final int INTERVAL_ARRAY = 1187;
+    public static final int CHAR = 18; // This is not char(N), this is "char" a single byte type.
+    public static final int CHAR_ARRAY = 1002;
+    public static final int VARBIT = 1562;
+    public static final int VARBIT_ARRAY = 1563;
+    public static final int UUID = 2950;
+    public static final int UUID_ARRAY = 2951;
+    public static final int XML = 142;
+    public static final int XML_ARRAY = 143;
+
+}

=== added file 'src/org/postgresql/driver/core/PGBindException.java'
--- src/org/postgresql/driver/core/PGBindException.java	1970-01-01 00:00:00 +0000
+++ src/org/postgresql/driver/core/PGBindException.java	2011-08-30 20:30:24 +0000
@@ -0,0 +1,38 @@
+/*****************************************************************************
+ * Copyright (C) 2008 EnterpriseDB Corporation.
+ * Copyright (C) 2011 Stado Global Development Group.
+ *
+ * This file is part of Stado.
+ *
+ * Stado is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Stado is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Stado.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * You can find Stado at http://www.stado.us
+ *
+ ****************************************************************************/
+package org.postgresql.driver.core;
+
+import java.io.IOException;
+
+public class PGBindException extends IOException {
+
+    private IOException _ioe;
+
+    public PGBindException(IOException ioe) {
+        _ioe = ioe;
+    }
+
+    public IOException getIOException() {
+        return _ioe;
+    }
+}

=== added file 'src/org/postgresql/driver/core/PGStream.java'
--- src/org/postgresql/driver/core/PGStream.java	1970-01-01 00:00:00 +0000
+++ src/org/postgresql/driver/core/PGStream.java	2011-08-30 20:30:24 +0000
@@ -0,0 +1,565 @@
+/*****************************************************************************
+ * Copyright (C) 2008 EnterpriseDB Corporation.
+ * Copyright (C) 2011 Stado Global Development Group.
+ *
+ * This file is part of Stado.
+ *
+ * Stado is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Stado is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Stado.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * You can find Stado at http://www.stado.us
+ *
+ ****************************************************************************/
+package org.postgresql.driver.core;
+
+import java.io.BufferedOutputStream;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.FilterOutputStream;
+import java.io.IOException;
+import java.io.EOFException;
+import java.io.Writer;
+import java.net.Socket;
+import java.sql.*;
+
+import org.postgresql.driver.util.GT;
+import org.postgresql.driver.util.PSQLException;
+import org.postgresql.driver.util.PSQLState;
+
+/**
+ * Wrapper around the raw connection to the server that implements some basic
+ * primitives (reading/writing formatted data, doing string encoding, etc).
+ *<p>
+ * In general, instances of PGStream are not threadsafe; the caller must ensure
+ * that only one thread at a time is accessing a particular PGStream instance.
+ */
+public class PGStream
+{
+    private final String host;
+    private final int port;
+
+    private final byte[] _int4buf;
+    private final byte[] _int2buf;
+
+    private Socket connection;
+    private VisibleBufferedInputStream pg_input;
+    private OutputStream pg_output;
+    private byte[] streamBuffer;
+
+    private Encoding encoding;
+    private Writer encodingWriter;
+
+    /**
+     * Constructor:  Connect to the PostgreSQL back end and return
+     * a stream connection.
+     *
+     * @param host the hostname to connect to
+     * @param port the port number that the postmaster is sitting on
+     * @exception IOException if an IOException occurs below it.
+     */
+    public PGStream(String host, int port) throws IOException
+    {
+        this.host = host;
+        this.port = port;
+
+        changeSocket(new Socket(host, port));
+        setEncoding(Encoding.getJVMEncoding("US-ASCII"));
+
+        _int2buf = new byte[2];
+        _int4buf = new byte[4];
+    }
+
+    public String getHost() {
+        return host;
+    }
+
+    public int getPort() {
+        return port;
+    }
+
+    public Socket getSocket() {
+        return connection;
+    }
+
+    /**
+     * Check for pending backend messages without blocking.
+     * Might return false when there actually are messages
+     * waiting, depending on the characteristics of the
+     * underlying socket. This is used to detect asynchronous
+     * notifies from the backend, when available.
+     *
+     * @return true if there is a pending backend message
+     */
+    public boolean hasMessagePending() throws IOException {
+        return pg_input.available() > 0 || connection.getInputStream().available() > 0;
+    }
+
+    /**
+     * Switch this stream to using a new socket. Any existing socket
+     * is <em>not</em> closed; it's assumed that we are changing to
+     * a new socket that delegates to the original socket (e.g. SSL).
+     *
+     * @param socket the new socket to change to
+     * @throws IOException if something goes wrong
+     */
+    public void changeSocket(Socket socket) throws IOException {
+        this.connection = socket;
+
+        // Submitted by Jason Venner <[e-mail]>. Disable Nagle
+        // as we are selective about flushing output only when we
+        // really need to.
+        connection.setTcpNoDelay(true);
+
+        // Buffer sizes submitted by Sverre H Huseby <[e-mail]>
+        pg_input = new VisibleBufferedInputStream(connection.getInputStream(), 8192);
+        pg_output = new BufferedOutputStream(connection.getOutputStream(), 8192);
+
+        if (encoding != null)
+            setEncoding(encoding);
+    }
+
+    public Encoding getEncoding() {
+        return encoding;
+    }
+
+    /**
+     * Change the encoding used by this connection.
+     *
+     * @param encoding the new encoding to use
+     * @throws IOException if something goes wrong
+     */
+    public void setEncoding(Encoding encoding) throws IOException {
+        // Close down any old writer.
+        if (encodingWriter != null)
+            encodingWriter.close();
+
+        this.encoding = encoding;
+
+        // Intercept flush() downcalls from the writer; our caller
+        // will call PGStream.flush() as needed.
+        OutputStream interceptor = new FilterOutputStream(pg_output) {
+                                       public void flush() throws IOException {
+                                       }
+                                       public void close() throws IOException {
+                                           super.flush();
+                                       }
+                                   };
+
+        encodingWriter = encoding.getEncodingWriter(interceptor);
+    }
+
+    /**
+     * Get a Writer instance that encodes directly onto the underlying stream.
+     *<p>
+     * The returned Writer should not be closed, as it's a shared object.
+     * Writer.flush needs to be called when switching between use of the Writer and
+     * use of the PGStream write methods, but it won't actually flush output
+     * all the way out -- call {@link #flush} to actually ensure all output
+     * has been pushed to the server.
+     *
+     * @return the shared Writer instance
+     * @throws IOException if something goes wrong.
+     */
+    public Writer getEncodingWriter() throws IOException {
+        if (encodingWriter == null)
+            throw new IOException("No encoding has been set on this connection");
+        return encodingWriter;
+    }
+
+    /**
+     * Sends a single character to the back end
+     *
+     * @param val the character to be sent
+     * @exception IOException if an I/O error occurs
+     */
+    public void SendChar(int val) throws IOException
+    {
+        pg_output.write(val);
+    }
+
+    /**
+     * Sends a 4-byte integer to the back end
+     *
+     * @param val the integer to be sent
+     * @exception IOException if an I/O error occurs
+     */
+    public void SendInteger4(int val) throws IOException
+    {
+        _int4buf[0] = (byte)(val >>> 24);
+        _int4buf[1] = (byte)(val >>> 16);
+        _int4buf[2] = (byte)(val >>> 8);
+        _int4buf[3] = (byte)(val);
+        pg_output.write(_int4buf);
+    }
+
+    /**
+     * Sends a 2-byte integer (short) to the back end
+     *
+     * @param val the integer to be sent
+     * @exception IOException if an I/O error occurs or <code>val</code> cannot be encoded in 2 bytes
+     */
+    public void SendInteger2(int val) throws IOException
+    {
+        if (val < Short.MIN_VALUE || val > Short.MAX_VALUE)
+            throw new IOException("Tried to send an out-of-range integer as a 2-byte value: " + val);
+
+        _int2buf[0] = (byte)(val >>> 8);
+        _int2buf[1] = (byte)val;
+        pg_output.write(_int2buf);
+    }
+
+    /**
+     * Send an array of bytes to the backend
+     *
+     * @param buf The array of bytes to be sent
+     * @exception IOException if an I/O error occurs
+     */
+    public void Send(byte buf[]) throws IOException
+    {
+        pg_output.write(buf);
+    }
+
+    /**
+     * Send a fixed-size array of bytes to the backend. If buf.length < siz,
+     * pad with zeros. If buf.lengh > siz, truncate the array.
+     *
+     * @param buf the array of bytes to be sent
+     * @param siz the number of bytes to be sent
+     * @exception IOException if an I/O error occurs
+     */
+    public void Send(byte buf[], int siz) throws IOException
+    {
+        Send(buf, 0, siz);
+    }
+
+    /**
+     * Send a fixed-size array of bytes to the backend. If length < siz,
+     * pad with zeros. If length > siz, truncate the array.
+     *
+     * @param buf the array of bytes to be sent
+     * @param off offset in the array to start sending from
+     * @param siz the number of bytes to be sent
+     * @exception IOException if an I/O error occurs
+     */
+    public void Send(byte buf[], int off, int siz) throws IOException
+    {
+	int bufamt = buf.length - off;
+        pg_output.write(buf, off, bufamt < siz ? bufamt : siz);
+        for (int i = bufamt ; i < siz ; ++i)
+        {
+            pg_output.write(0);
+        }
+    }
+
+    /**
+     * Receives a single character from the backend, without
+     * advancing the current protocol stream position.
+     *
+     * @return the character received
+     * @exception IOException if an I/O Error occurs
+     */
+    public int PeekChar() throws IOException
+    {
+        int c = pg_input.peek();
+        if (c < 0)
+            throw new EOFException();
+        return c;
+    }
+
+    /**
+     * Receives a single character from the backend
+     *
+     * @return the character received
+     * @exception IOException if an I/O Error occurs
+     */
+    public int ReceiveChar() throws IOException
+    {
+        int c = pg_input.read();
+        if (c < 0)
+            throw new EOFException();
+        return c;
+    }
+
+    /**
+     * Receives a four byte integer from the backend
+     *
+     * @return the integer received from the backend
+     * @exception IOException if an I/O error occurs
+     */
+    public int ReceiveInteger4() throws IOException
+    {
+        if (pg_input.read(_int4buf) != 4)
+            throw new EOFException();
+
+        return (_int4buf[0] & 0xFF) << 24 | (_int4buf[1] & 0xFF) << 16 | (_int4buf[2] & 0xFF) << 8 | _int4buf[3] & 0xFF;
+    }
+
+    /**
+     * Receives a two byte integer from the backend
+     *
+     * @return the integer received from the backend
+     * @exception IOException if an I/O error occurs
+     */
+    public int ReceiveInteger2() throws IOException
+    {
+        if (pg_input.read(_int2buf) != 2)
+            throw new EOFException();
+
+        return (_int2buf[0] & 0xFF) << 8 | _int2buf[1] & 0xFF;
+    }
+
+    /**
+     * Receives a fixed-size string from the backend.
+     *
+     * @param len the length of the string to receive, in bytes.
+     * @return the decoded string
+     */
+    public String ReceiveString(int len) throws IOException {
+        if (!pg_input.ensureBytes(len)) {
+            throw new EOFException();
+        }
+
+        String res = encoding.decode(pg_input.getBuffer(), pg_input.getIndex(),
+                                     len);
+        pg_input.skip(len);
+        return res;
+    }
+
+    /**
+     * Receives a null-terminated string from the backend. If we don't see a
+     * null, then we assume something has gone wrong.
+     *
+     * @return string from back end
+     * @exception IOException if an I/O error occurs, or end of file
+     */
+    public String ReceiveString() throws IOException
+    {
+        int len = pg_input.scanCStringLength();
+        String res = encoding.decode(pg_input.getBuffer(), pg_input.getIndex(),
+                                     len - 1);
+        pg_input.skip(len);
+        return res;
+    }
+
+    /**
+     * Read a tuple from the back end. A tuple is a two dimensional
+     * array of bytes. This variant reads the V3 protocol's tuple
+     * representation.
+     *
+     * @return null if the current response has no more tuples, otherwise
+     * an array of bytearrays
+     * @exception IOException if a data I/O error occurs
+     */
+    public byte[][] ReceiveTupleV3() throws IOException, OutOfMemoryError
+    {
+        //TODO: use l_msgSize
+        int l_msgSize = ReceiveInteger4();
+        int i;
+        int l_nf = ReceiveInteger2();
+        byte[][] answer = new byte[l_nf][];
+
+        OutOfMemoryError oom = null;
+        for (i = 0 ; i < l_nf ; ++i)
+        {
+            int l_size = ReceiveInteger4();
+            if (l_size != -1) {
+                try {
+                    answer[i] = new byte[l_size];
+                    Receive(answer[i], 0, l_size);
+                } catch(OutOfMemoryError oome) {
+                    oom = oome;
+                    Skip(l_size);
+                }
+            }
+        }
+
+        if (oom != null)
+            throw oom;
+
+        return answer;
+    }
+
+    /**
+     * Read a tuple from the back end. A tuple is a two dimensional
+     * array of bytes. This variant reads the V2 protocol's tuple
+     * representation.
+     *
+     * @param nf the number of fields expected
+     * @param bin true if the tuple is a binary tuple
+     * @return null if the current response has no more tuples, otherwise
+     * an array of bytearrays
+     * @exception IOException if a data I/O error occurs
+     */
+    public byte[][] ReceiveTupleV2(int nf, boolean bin) throws IOException, OutOfMemoryError
+    {
+        int i, bim = (nf + 7) / 8;
+        byte[] bitmask = Receive(bim);
+        byte[][] answer = new byte[nf][];
+
+        int whichbit = 0x80;
+        int whichbyte = 0;
+
+        OutOfMemoryError oom = null;
+        for (i = 0 ; i < nf ; ++i)
+        {
+            boolean isNull = ((bitmask[whichbyte] & whichbit) == 0);
+            whichbit >>= 1;
+            if (whichbit == 0)
+            {
+                ++whichbyte;
+                whichbit = 0x80;
+            }
+            if (!isNull)
+            {
+                int len = ReceiveInteger4();
+                if (!bin)
+                    len -= 4;
+                if (len < 0)
+                    len = 0;
+                try {
+                    answer[i] = new byte[len];
+                    Receive(answer[i], 0, len);
+                } catch(OutOfMemoryError oome) {
+                    oom = oome;
+                    Skip(len);
+                }
+            }
+        }
+
+        if (oom != null)
+            throw oom;
+
+        return answer;
+    }
+
+    /**
+     * Reads in a given number of bytes from the backend
+     *
+     * @param siz number of bytes to read
+     * @return array of bytes received
+     * @exception IOException if a data I/O error occurs
+     */
+    public byte[] Receive(int siz) throws IOException
+    {
+        byte[] answer = new byte[siz];
+        Receive(answer, 0, siz);
+        return answer;
+    }
+
+    /**
+     * Reads in a given number of bytes from the backend
+     *
+     * @param buf buffer to store result
+     * @param off offset in buffer
+     * @param siz number of bytes to read
+     * @exception IOException if a data I/O error occurs
+     */
+    public void Receive(byte[] buf, int off, int siz) throws IOException
+    {
+        int s = 0;
+
+        while (s < siz)
+        {
+            int w = pg_input.read(buf, off + s, siz - s);
+            if (w < 0)
+                throw new EOFException();
+            s += w;
+        }
+    }
+
+    public void Skip(int size) throws IOException {
+        long s = 0;
+        while (s < size) {
+            s += pg_input.skip(size - s);
+        }
+    }
+
+
+    /**
+     * Copy data from an input stream to the connection.
+     *
+     * @param inStream the stream to read data from
+     * @param remaining the number of bytes to copy
+     */
+    public void SendStream(InputStream inStream, int remaining) throws IOException {
+        int expectedLength = remaining;
+        if (streamBuffer == null)
+            streamBuffer = new byte[8192];
+
+        while (remaining > 0)
+        {
+            int count = (remaining > streamBuffer.length ? streamBuffer.length : remaining);
+            int readCount;
+
+            try
+            {
+                readCount = inStream.read(streamBuffer, 0, count);
+                if (readCount < 0)
+                    throw new EOFException(GT.tr("Premature end of input stream, expected {0} bytes, but only read {1}.", new Object[]{new Integer(expectedLength), new Integer(expectedLength - remaining)}));
+            }
+            catch (IOException ioe)
+            {
+                while (remaining > 0)
+                {
+                    Send(streamBuffer, count);
+                    remaining -= count;
+                    count = (remaining > streamBuffer.length ? streamBuffer.length : remaining);
+                }
+                throw new PGBindException(ioe);
+            }
+
+            Send(streamBuffer, readCount);
+            remaining -= readCount;
+        }
+    }
+
+
+
+    /**
+     * Flush any pending output to the backend.
+     * @exception IOException if an I/O error occurs
+     */
+    public void flush() throws IOException
+    {
+        if (encodingWriter != null)
+            encodingWriter.flush();
+        pg_output.flush();
+    }
+
+    /**
+     * Consume an expected EOF from the backend
+     * @exception SQLException if we get something other than an EOF
+     */
+    public void ReceiveEOF() throws SQLException, IOException
+    {
+        int c = pg_input.read();
+        if (c < 0)
+            return;
+        throw new PSQLException(GT.tr("Expected an EOF from server, got: {0}", new Integer(c)), PSQLState.COMMUNICATION_ERROR);
+    }
+
+    /**
+     * Closes the connection
+     *
+     * @exception IOException if an I/O Error occurs
+     */
+    public void close() throws IOException
+    {
+        if (encodingWriter != null)
+            encodingWriter.close();
+
+        pg_output.close();
+        pg_input.close();
+        connection.close();
+    }
+}

=== added file 'src/org/postgresql/driver/core/ParameterList.java'
--- src/org/postgresql/driver/core/ParameterList.java	1970-01-01 00:00:00 +0000
+++ src/org/postgresql/driver/core/ParameterList.java	2011-08-30 20:30:24 +0000
@@ -0,0 +1,171 @@
+/*****************************************************************************
+ * Copyright (C) 2008 EnterpriseDB Corporation.
+ * Copyright (C) 2011 Stado Global Development Group.
+ *
+ * This file is part of Stado.
+ *
+ * Stado is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Stado is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Stado.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * You can find Stado at http://www.stado.us
+ *
+ ****************************************************************************/
+package org.postgresql.driver.core;
+
+import java.sql.SQLException;
+import java.io.InputStream;
+
+/**
+ * Abstraction of a list of parameters to be substituted into a Query.
+ * The protocol-specific details of how to efficiently store and stream
+ * the parameters is hidden behind implementations of this interface.
+ *<p>
+ * In general, instances of ParameterList are associated with a particular
+ * Query object (the one that created them) and shouldn't be used against
+ * another Query.
+ *<p>
+ * Parameter indexes are 1-based to match JDBC's PreparedStatement, i.e.
+ * the first parameter has index 1.
+ *
+ * @author Oliver Jowett ([e-mail])
+ */
+public interface ParameterList {
+    
+    
+    void registerOutParameter( int index, int sqlType ) throws SQLException;
+    /**
+     * Get the number of parameters in this list. This value never changes
+     * for a particular instance, and might be zero.
+     *
+     * @return the number of parameters in this list.
+     */
+    int getParameterCount();
+    
+    /**
+     * Get the number of IN parameters in this list. 
+     * 
+     * @return the number of IN parameters in this list
+     */
+    int getInParameterCount();
+
+    /**
+     * Get the number of OUT parameters in this list. 
+     * 
+     * @return the number of OUT parameters in this list
+     */
+    int getOutParameterCount();
+
+    /**
+     * Return the oids of the parameters in this list.  May be null for
+     * a ParameterList that does not support typing of parameters.
+     */
+    public int[] getTypeOIDs();
+
+    /**
+     * Binds an integer value to a parameter. The type of the parameter is
+     * implicitly 'int4'.
+     *
+     * @param index the 1-based parameter index to bind.
+     * @param value the integer value to use.
+     * @throws SQLException on error or if <code>index</code> is out of range
+     */
+    void setIntParameter(int index, int value) throws SQLException;
+
+    /**
+     * Binds a String value that is an unquoted literal to the
+     * server's query parser (for example, a bare integer) to a parameter.
+     * Associated with the parameter is a typename for the parameter that
+     * should correspond to an entry in pg_types.
+     *
+     * @param index the 1-based parameter index to bind.
+     * @param value the unquoted literal string to use.
+     * @param oid the type OID of the parameter, or <code>0</code>
+     *   to infer the type.
+     * @throws SQLException on error or if <code>index</code> is out of range
+     */
+    void setLiteralParameter(int index, String value, int oid) throws SQLException;
+
+    /**
+     * Binds a String value that needs to be quoted for the server's parser
+     * to understand (for example, a timestamp) to a parameter.
+     * Associated with the parameter is a typename for the parameter that
+     * should correspond to an entry in pg_types.
+     *
+     * @param index the 1-based parameter index to bind.
+     * @param value the quoted string to use.
+     * @param oid the type OID of the parameter, or <code>0</code>
+     *   to infer the type.
+     * @throws SQLException on error or if <code>index</code> is out of range
+     */
+    void setStringParameter(int index, String value, int oid) throws SQLException;
+
+    /**
+     * Binds a binary bytea value stored as a bytearray to a parameter. The
+     * parameter's type is implicitly set to 'bytea'. The bytearray's
+     * contains should remain unchanged until query execution has completed.
+     *
+     * @param index the 1-based parameter index to bind.
+     * @param data an array containing the raw data value
+     * @param offset the offset within <code>data</code> of the start of the parameter data.
+     * @param length the number of bytes of parameter data within <code>data</code> to use.
+     * @throws SQLException on error or if <code>index</code> is out of range
+     */
+    void setBytea(int index, byte[] data, int offset, int length) throws SQLException;
+
+    /**
+     * Binds a binary bytea value stored as an InputStream. The
+     * parameter's type is implicitly set to 'bytea'. The stream should
+     * remain valid until query execution has completed.
+     *
+     * @param index the 1-based parameter index to bind.
+     * @param stream a stream containing the parameter data.
+     * @param length the number of bytes of parameter data to read from <code>stream</code>.
+     * @throws SQLException on error or if <code>index</code> is out of range
+     */
+    void setBytea(int index, InputStream stream, int length) throws SQLException;
+
+    /**
+     * Binds a SQL NULL value to a parameter.
+     * Associated with the parameter is a typename for the parameter that
+     * should correspond to an entry in pg_types.
+     *
+     * @param index the 1-based parameter index to bind.
+     * @param oid the type OID of the parameter, or <code>0</code>
+     *   to infer the type.
+     * @throws SQLException on error or if <code>index</code> is out of range
+     */
+    void setNull(int index, int oid) throws SQLException;
+
+    /**
+     * Perform a shallow copy of this ParameterList, returning a new instance
+     * (still suitable for passing to the owning Query). If this ParameterList
+     * is immutable, copy() may return the same immutable object.
+     *
+     * @return a new ParameterList instance
+     */
+    ParameterList copy();
+
+    /**
+     * Unbind all parameter values bound in this list.
+     */
+    void clear();
+
+    /**
+     * Return a human-readable representation of a particular parameter in
+     * this ParameterList. If the parameter is not bound, returns "?".
+     *
+     * @param index the 1-based parameter index to bind.
+     * @return a string representation of the parameter.
+     */
+    String toString(int index);
+}

=== added file 'src/org/postgresql/driver/core/Parser.java'
--- src/org/postgresql/driver/core/Parser.java	1970-01-01 00:00:00 +0000
+++ src/org/postgresql/driver/core/Parser.java	2011-08-30 20:30:24 +0000
@@ -0,0 +1,316 @@
+/*****************************************************************************
+ * Copyright (C) 2008 EnterpriseDB Corporation.
+ * Copyright (C) 2011 Stado Global Development Group.
+ *
+ * This file is part of Stado.
+ *
+ * Stado is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Stado is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Stado.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * You can find Stado at http://www.stado.us
+ *
+ ****************************************************************************/
+package org.postgresql.driver.core;
+
+/**
+ * Basic query parser infrastructure.
+ * 
+ * @author Michael Paesold ([e-mail])
+ */
+public class Parser {
+
+    /**
+     * Find the end of the single-quoted string starting at the given offset.
+     * 
+     * Note: for <tt>'single '' quote in string'</tt>, this method currently
+     * returns the offset of first <tt>'</tt> character after the initial
+     * one. The caller must call the method a second time for the second
+     * part of the quoted string.
+     */
+    public static int parseSingleQuotes(final char[] query, int offset,
+                                        boolean standardConformingStrings) {
+        // check for escape string syntax (E'')
+        if (standardConformingStrings
+                && offset >= 2
+                && (query[offset-1] == 'e' || query[offset-1] == 'E')
+                && charTerminatesIdentifier(query[offset-2]))
+        {
+            standardConformingStrings = false;
+        }
+        
+        if (standardConformingStrings)
+        {
+            // do NOT treat backslashes as escape characters
+            while (++offset < query.length)
+            {
+                switch (query[offset])
+                {
+                case '\'':
+                    return offset;
+                default:
+                    break;
+                }
+            }
+        }
+        else
+        {
+            // treat backslashes as escape characters
+            while (++offset < query.length)
+            {
+                switch (query[offset])
+                {
+                case '\\':
+                    ++offset;
+                    break;
+                case '\'':
+                    return offset;
+                default:
+                    break;
+                }
+            }
+        }
+        
+        return query.length;
+    }
+
+    /**
+     * Find the end of the double-quoted string starting at the given offset.
+     *
+     * Note: for <tt>&quot;double &quot;&quot; quote in string&quot;</tt>,
+     * this method currently returns the offset of first <tt>&quot;</tt>
+     * character after the initial one. The caller must call the method a
+     * second time for the second part of the quoted string.
+     */
+    public static int parseDoubleQuotes(final char[] query, int offset) {
+        while (++offset < query.length && query[offset] != '"') ;
+        return offset;
+    }
+
+    /**
+     * Test if the dollar character (<tt>$</tt>) at the given offset starts
+     * a dollar-quoted string and return the offset of the ending dollar
+     * character.
+     */
+    public static int parseDollarQuotes(final char[] query, int offset) {
+        if (offset + 1 < query.length
+                && (offset == 0 || !isIdentifierContChar(query[offset-1])))
+        {
+            int endIdx = -1;
+            if (query[offset + 1] == '$')
+                endIdx = offset + 1;
+            else if (isDollarQuoteStartChar(query[offset + 1]))
+            {
+                for (int d = offset + 2; d < query.length; ++d)
+                {
+                    if (query[d] == '$')
+                    {
+                        endIdx = d;
+                        break;
+                    }
+                    else if (!isDollarQuoteContChar(query[d]))
+                        break;
+                }
+            }
+            if (endIdx > 0)
+            {
+                // found; note: tag includes start and end $ character
+                int tagIdx = offset, tagLen = endIdx - offset + 1;
+                offset = endIdx; // loop continues at endIdx + 1
+                for (++offset; offset < query.length; ++offset)
+                {
+                    if (query[offset] == '$' &&
+                        subArraysEqual(query, tagIdx, offset, tagLen))
+                    {
+                        offset += tagLen - 1;
+                        break;
+                    }
+                }
+            }
+        }        
+        return offset;
+    }
+
+    /**
+     * Test if the <tt>-</tt> character at <tt>offset</tt> starts a
+     * <tt>--</tt> style line comment, and return the position of the first
+     * <tt>\r</tt> or <tt>\n</tt> character.
+     */
+    public static int parseLineComment(final char[] query, int offset) {
+        if (offset + 1 < query.length && query[offset + 1] == '-')
+        {
+            while (++offset < query.length)
+            {
+                if (query[offset] == '\r' || query[offset] == '\n')
+                    break;
+            }
+        }
+        return offset;
+    }
+
+    /**
+     * Test if the <tt>/</tt> character at <tt>offset</tt> starts a block
+     * comment, and return the position of the last <tt>/</tt> character.
+     */
+    public static int parseBlockComment(final char[] query, int offset) {
+        if (offset + 1 < query.length && query[offset + 1] == '*')
+        {
+            // /* /* */ */ nest, according to SQL spec
+            int level = 1;
+            for (offset += 2; offset < query.length; ++offset)
+            {
+                switch (query[offset-1])
+                {
+                case '*':
+                    if (query[offset] == '/')
+                    {
+                        --level;
+                        ++offset; // don't parse / in */* twice
+                    }
+                    break;
+                case '/':
+                    if (query[offset] == '*')
+                    {
+                        ++level;
+                        ++offset; // don't parse * in /*/ twice
+                    }
+                    break;
+                default:
+                    break;
+                }
+
+                if (level == 0)
+                {
+                    --offset; // reset position to last '/' char
+                    break;
+                }
+            }
+        }
+        return offset;
+    }
+    
+    /**
+     * @return true if the character is a whitespace character as defined
+     *         in the backend's parser
+     */
+    public static boolean isSpace(char c) {
+       return c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\f';
+    }
+    
+    /**
+     * @return true if the given character is a valid character for an
+     *         operator in the backend's parser
+     */
+    public static boolean isOperatorChar(char c) {
+        /*
+         * Extracted from operators defined by {self} and {op_chars}
+         * in pgsql/src/backend/parser/scan.l.
+         */
+        return ",()[].;:+-*/%^<>=~!@#&|`?".indexOf(c) != -1;
+    }
+
+    /**
+     * Checks if a character is valid as the start of an identifier.
+     * 
+     * @param c the character to check
+     * @return true if valid as first character of an identifier; false if not
+     */
+    public static boolean isIdentifierStartChar(char c) {
+        /*
+         * Extracted from {ident_start} and {ident_cont} in
+         * pgsql/src/backend/parser/scan.l:
+         * ident_start    [A-Za-z\200-\377_]
+         * ident_cont     [A-Za-z\200-\377_0-9\$]
+         */
+        return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')
+                || c == '_' || c > 127 ;
+    }
+    
+    /**
+     * Checks if a character is valid as the second or later character of an
+     * identifier.
+     * 
+     * @param c the character to check
+     * @return true if valid as second or later character of an identifier; false if not
+     */
+    public static boolean isIdentifierContChar(char c) {
+        return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')
+                || c == '_' || c > 127
+                || (c >= '0' && c <= '9')
+                || c == '$';
+    }
+    
+    /**
+     * @return true if the character terminates an identifier
+     */
+    public static boolean charTerminatesIdentifier(char c) {
+        return c == '"' || isSpace(c) || isOperatorChar(c);
+    }
+
+    /**
+     * Checks if a character is valid as the start of a dollar quoting tag.
+     * 
+     * @param c the character to check
+     * @return true if valid as first character of a dollar quoting tag; false if not
+     */
+    public static boolean isDollarQuoteStartChar(char c) {
+        /*
+         * The allowed dollar quote start and continuation characters
+         * must stay in sync with what the backend defines in
+         * pgsql/src/backend/parser/scan.l
+         */
+        return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')
+                || c == '_' || c > 127;
+    }
+
+    /**
+     * Checks if a character is valid as the second or later character of a
+     * dollar quoting tag.
+     * 
+     * @param c the character to check
+     * @return true if valid as second or later character of a dollar quoting tag;
+     *         false if not
+     */
+    public static boolean isDollarQuoteContChar(char c) {
+        return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')
+                || c == '_' || c > 127
+                || (c >= '0' && c <= '9');
+    }
+
+    /**
+     * Compares two sub-arrays of the given character array for equalness.
+     * If the length is zero, the result is true if and only if the offsets
+     * are within the bounds of the array.
+     * 
+     * @param arr  a char array
+     * @param offA first sub-array start offset
+     * @param offB second sub-array start offset
+     * @param len  length of the sub arrays to compare
+     * @return     true if the sub-arrays are equal; false if not
+     */
+    private static boolean subArraysEqual(final char[] arr,
+                                          final int offA, final int offB,
+                                          final int len) {
+        if (offA < 0 || offB < 0
+                || offA >= arr.length || offB >= arr.length
+                || offA + len > arr.length || offB + len > arr.length)
+            return false;
+        
+        for (int i = 0; i < len; ++i)
+        {
+            if (arr[offA + i] != arr[offB + i])
+                return false;
+        }
+    
+        return true;
+    }
+}

=== added file 'src/org/postgresql/driver/core/ProtocolConnection.java'
--- src/org/postgresql/driver/core/ProtocolConnection.java	1970-01-01 00:00:00 +0000
+++ src/org/postgresql/driver/core/ProtocolConnection.java	2011-08-30 20:30:24 +0000
@@ -0,0 +1,148 @@
+/*****************************************************************************
+ * Copyright (C) 2008 EnterpriseDB Corporation.
+ * Copyright (C) 2011 Stado Global Development Group.
+ *
+ * This file is part of Stado.
+ *
+ * Stado is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Stado is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Stado.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * You can find Stado at http://www.stado.us
+ *
+ ****************************************************************************/
+package org.postgresql.driver.core;
+
+import org.postgresql.driver.PGNotification;
+
+import java.sql.*;
+
+/**
+ * Provides access to protocol-level connection operations.
+ *
+ * @author Oliver Jowett ([e-mail])
+ */
+public interface ProtocolConnection {
+    /**
+     * Constant returned by {@link #getTransactionState} indicating that no
+     * transaction is currently open.
+     */
+    static final int TRANSACTION_IDLE = 0;
+
+    /**
+     * Constant returned by {@link #getTransactionState} indicating that a
+     * transaction is currently open.
+     */
+    static final int TRANSACTION_OPEN = 1;
+
+    /**
+     * Constant returned by {@link #getTransactionState} indicating that a
+     * transaction is currently open, but it has seen errors and will
+     * refuse subsequent queries until a ROLLBACK.
+     */
+    static final int TRANSACTION_FAILED = 2;
+
+    /**
+     * @return the hostname this connection is connected to.
+     */
+    String getHost();
+
+    /**
+     * @return the port number this connection is connected to.
+     */
+    int getPort();
+
+    /**
+     * @return the user this connection authenticated as.
+     */
+    String getUser();
+
+    /**
+     * @return the database this connection is connected to.
+     */
+    String getDatabase();
+
+    /**
+     * @return the server version of the connected server, formatted as X.Y.Z.
+     */
+    String getServerVersion();
+
+    /**
+     * @return the current encoding in use by this connection
+     */
+    Encoding getEncoding();
+    
+    /**
+     * Returns whether the server treats string-literals according to the SQL
+     * standard or if it uses traditional PostgreSQL escaping rules. Versions
+     * up to 8.1 always treated backslashes as escape characters in
+     * string-literals. Since 8.2, this depends on the value of the
+     * <tt>standard_conforming_strings<tt> server variable.
+     * 
+     * @return true if the server treats string literals according to the SQL
+     *   standard
+     */
+    boolean getStandardConformingStrings();
+
+    /**
+     * Get the current transaction state of this connection.
+     * 
+     * @return a ProtocolConnection.TRANSACTION_* constant.
+     */
+    int getTransactionState();
+
+    /**
+     * Retrieve and clear the set of asynchronous notifications pending on this
+     * connection.
+     *
+     * @return an array of notifications; if there are no notifications, an empty
+     *   array is returned.
+     */
+    PGNotification[] getNotifications() throws SQLException;
+
+    /**
+     * Retrieve and clear the chain of warnings accumulated on this connection.
+     *
+     * @return the first SQLWarning in the chain; subsequent warnings can be
+     *   found via SQLWarning.getNextWarning().
+     */
+    SQLWarning getWarnings();
+
+    /**
+     * @return the QueryExecutor instance for this connection.
+     */
+    QueryExecutor getQueryExecutor();
+
+    /**
+     * Sends a query cancellation for this connection.
+     * @throws SQLException if something goes wrong.
+     */
+    void sendQueryCancel() throws SQLException;
+
+    /**
+     * Close this connection cleanly.
+     */
+    void close();
+
+    /**
+     * Check if this connection is closed.
+     *
+     * @return true iff the connection is closed.
+     */
+    boolean isClosed();
+    
+    /**
+     * 
+     * @return the version of the implementation
+     */
+    public int getProtocolVersion();
+}

=== added file 'src/org/postgresql/driver/core/Query.java'
--- src/org/postgresql/driver/core/Query.java	1970-01-01 00:00:00 +0000
+++ src/org/postgresql/driver/core/Query.java	2011-08-30 20:30:24 +0000
@@ -0,0 +1,69 @@
+/*****************************************************************************
+ * Copyright (C) 2008 EnterpriseDB Corporation.
+ * Copyright (C) 2011 Stado Global Development Group.
+ *
+ * This file is part of Stado.
+ *
+ * Stado is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Stado is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Stado.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * You can find Stado at http://www.stado.us
+ *
+ ****************************************************************************/
+package org.postgresql.driver.core;
+
+/**
+ * Abstraction of a generic Query, hiding the details of
+ * any protocol-version-specific data needed to execute
+ * the query efficiently.
+ *<p>
+ * Query objects should be explicitly closed when no longer
+ * needed; if resources are allocated on the server for this
+ * query, their cleanup is triggered by closing the Query.
+ *
+ * @author Oliver Jowett ([e-mail])
+ */
+public interface Query {
+    /**
+     * Create a ParameterList suitable for storing parameters
+     * associated with this Query.
+     *<p>
+     * If this query has no parameters, a ParameterList will
+     * be returned, but it may be a shared immutable object.
+     * If this query does have parameters, the returned
+     * ParameterList is a new list, unshared by other callers.
+     *
+     * @return a suitable ParameterList instance for this query
+     */
+    ParameterList createParameterList();
+
+    /**
+     * Stringize this query to a human-readable form, substituting
+     * particular parameter values for parameter placeholders.
+     *
+     * @param parameters a ParameterList returned by this Query's
+     *  {@link #createParameterList} method, or <code>null</code> to
+     *  leave the parameter placeholders unsubstituted.
+     * @return a human-readable representation of this query
+     */
+    String toString(ParameterList parameters);
+
+    /**
+     * Close this query and free any server-side resources associated
+     * with it. The resources may not be immediately deallocated, but
+     * closing a Query may make the deallocation more prompt.
+     *<p>
+     * A closed Query should not be executed.
+     */
+    void close();
+}

=== added file 'src/org/postgresql/driver/core/QueryExecutor.java'
--- src/org/postgresql/driver/core/QueryExecutor.java	1970-01-01 00:00:00 +0000
+++ src/org/postgresql/driver/core/QueryExecutor.java	2011-08-30 20:30:24 +0000
@@ -0,0 +1,236 @@
+/*****************************************************************************
+ * Copyright (C) 2008 EnterpriseDB Corporation.
+ * Copyright (C) 2011 Stado Global Development Group.
+ *
+ * This file is part of Stado.
+ *
+ * Stado is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Stado is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Stado.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * You can find Stado at http://www.stado.us
+ *
+ ****************************************************************************/
+package org.postgresql.driver.core;
+
+import java.sql.SQLException;
+
+import org.postgresql.driver.copy.CopyOperation;
+
+/**
+ * Abstracts the protocol-specific details of executing a query.
+ *<p>
+ * Every connection has a single QueryExecutor implementation associated with it.
+ * This object provides:
+ * 
+ * <ul>
+ *   <li> factory methods for Query objects ({@link #createSimpleQuery}
+ *        and {@link #createParameterizedQuery})
+ *   <li> execution methods for created Query objects ({@link #execute(Query,ParameterList,ResultHandler,int,int,int)}
+ *        for single queries and {@link #execute(Query[],ParameterList[],ResultHandler,int,int,int)} for batches of
+ *        queries)
+ *   <li> a fastpath call interface ({@link #createFastpathParameters}
+ *        and {@link #fastpathCall}).
+ * </ul>
+ *
+ *<p>
+ * Query objects may represent a query that has parameter placeholders. To provide
+ * actual values for these parameters, a {@link ParameterList} object is created
+ * via a factory method ({@link Query#createParameterList}). The parameters are filled
+ * in by the caller and passed along with the query to the query execution methods.
+ * Several ParameterLists for a given query might exist at one time (or over time);
+ * this allows the underlying Query to be reused for several executions, or for
+ * batch execution of the same Query.
+ *
+ *<p>
+ * In general, a Query created by a particular QueryExecutor may only be
+ * executed by that QueryExecutor, and a ParameterList created by a particular
+ * Query may only be used as parameters to that Query. Unpredictable things will
+ * happen if this isn't done.
+ *
+ * @author Oliver Jowett ([e-mail])
+ */
+public interface QueryExecutor {
+    /**
+     * Flag for query execution that indicates the given Query object is unlikely
+     * to be reused.
+     */
+    static int QUERY_ONESHOT = 1;
+
+    /**
+     * Flag for query execution that indicates that resultset metadata isn't needed
+     * and can be safely omitted.
+     */
+    static int QUERY_NO_METADATA = 2;
+
+    /**
+     * Flag for query execution that indicates that a resultset isn't expected and
+     * the query executor can safely discard any rows (although the resultset should
+     * still appear to be from a resultset-returning query).
+     */
+    static int QUERY_NO_RESULTS = 4;
+
+    /**
+     * Flag for query execution that indicates a forward-fetch-capable cursor should
+     * be used if possible.
+     */
+    static int QUERY_FORWARD_CURSOR = 8;
+
+    /**
+     * Flag for query execution that indicates the automatic BEGIN on the first statement
+     * when outside a transaction should not be done.
+     */
+    static int QUERY_SUPPRESS_BEGIN = 16;
+
+    /**
+     * Flag for query execution when we don't really want to execute, we just
+     * want to get the parameter metadata for the statement.
+     */
+    static int QUERY_DESCRIBE_ONLY = 32;
+
+    /**
+     * Flag for query execution used by generated keys where we want to receive
+     * both the ResultSet and associated update count from the command status.
+     */
+    static int QUERY_BOTH_ROWS_AND_STATUS = 64;
+
+    /**
+     * Execute a Query, passing results to a provided ResultHandler.
+     *
+     * @param query the query to execute; must be a query returned from
+     *  calling {@link #createSimpleQuery(String)} or {@link #createParameterizedQuery(String)}
+     *  on this QueryExecutor object.
+     * @param parameters the parameters for the query. Must be non-<code>null</code>
+     *  if the query takes parameters. Must be a parameter object returned by
+     *  {@link org.postgresql.driver.core.Query#createParameterList()}.
+     * @param handler a ResultHandler responsible for handling results generated
+     *  by this query
+     * @param maxRows the maximum number of rows to retrieve
+     * @param fetchSize if QUERY_FORWARD_CURSOR is set, the preferred number of rows to retrieve before suspending
+     * @param flags a combination of QUERY_* flags indicating how to handle the query.
+     *
+     * @throws SQLException if query execution fails
+     */
+    void execute(Query query,
+                 ParameterList parameters,
+                 ResultHandler handler,
+                 int maxRows,
+                 int fetchSize,
+                 int flags)
+    throws SQLException;
+
+    /**
+     * Execute several Query, passing results to a provided ResultHandler.
+     *
+     * @param queries the queries to execute; each must be a query returned from
+     *  calling {@link #createSimpleQuery(String)} or {@link #createParameterizedQuery(String)}
+     *  on this QueryExecutor object.
+     * @param parameterLists the parameter lists for the queries. The parameter lists
+     *  correspond 1:1 to the queries passed in the <code>queries</code> array. Each must be
+     *  non-<code>null</code> if the corresponding query takes parameters, and must
+     *  be a parameter object returned by {@link org.postgresql.driver.core.Query#createParameterList()}
+     *  created by the corresponding query.
+     * @param handler a ResultHandler responsible for handling results generated
+     *  by this query
+     * @param maxRows the maximum number of rows to retrieve
+     * @param fetchSize if QUERY_FORWARD_CURSOR is set, the preferred number of rows to retrieve before suspending
+     * @param flags a combination of QUERY_* flags indicating how to handle the query.
+     *
+     * @throws SQLException if query execution fails
+     */
+    void execute(Query[] queries,
+                 ParameterList[] parameterLists,
+                 ResultHandler handler,
+                 int maxRows,
+                 int fetchSize,
+                 int flags)
+    throws SQLException;
+
+    /**
+     * Fetch additional rows from a cursor.
+     *
+     * @param cursor the cursor to fetch from
+     * @param handler the handler to feed results to
+     * @param fetchSize the preferred number of rows to retrieve before suspending
+     * @throws SQLException if query execution fails
+     */
+    void fetch(ResultCursor cursor, ResultHandler handler, int fetchSize) throws SQLException;
+
+    /**
+     * Create an unparameterized Query object suitable for execution by
+     * this QueryExecutor. The provided query string is not parsed for
+     * parameter placeholders ('?' characters), and the 
+     * {@link Query#createParameterList} of the returned object will
+     * always return an empty ParameterList.
+     *
+     * @param sql the SQL for the query to create
+     * @return a new Query object
+     */
+    Query createSimpleQuery(String sql);
+
+    /**
+     * Create a parameterized Query object suitable for execution by
+     * this QueryExecutor. The provided query string is parsed for
+     * parameter placeholders ('?' characters), and the 
+     * {@link Query#createParameterList} of the returned object will
+     * create an appropriately-sized ParameterList.
+     *
+     * @param sql the SQL for the query to create, with '?' placeholders for
+     *   parameters.
+     * @return a new Query object
+     */
+    Query createParameterizedQuery(String sql); // Parsed for parameter placeholders ('?')
+
+    /**
+     * Prior to attempting to retrieve notifications, we need to pull
+     * any recently received notifications off of the network buffers.
+     * The notification retrieval in ProtocolConnection cannot do this
+     * as it is prone to deadlock, so the higher level caller must be
+     * responsible which requires exposing this method.
+     */
+    void processNotifies() throws SQLException;
+
+    //
+    // Fastpath interface.
+    //
+
+    /**
+     * Create a new ParameterList implementation suitable for invoking a
+     * fastpath function via {@link #fastpathCall}.
+     *
+     * @param count the number of parameters the fastpath call will take
+     * @return a ParameterList suitable for passing to {@link #fastpathCall}.
+     */
+    ParameterList createFastpathParameters(int count);
+
+    /**
+     * Invoke a backend function via the fastpath interface.
+     *
+     * @param fnid the OID of the backend function to invoke
+     * @param params a ParameterList returned from {@link #createFastpathParameters}
+     *  containing the parameters to pass to the backend function
+     *
+     * @return the binary-format result of the fastpath call, or <code>null</code>
+     *  if a void result was returned
+     * @throws SQLException if an error occurs while executing the fastpath call
+     */
+    byte[] fastpathCall(int fnid, ParameterList params, boolean suppressBegin) throws SQLException;
+
+    /**
+     * Issues a COPY FROM STDIN / COPY TO STDOUT statement and returns
+     * handler for associated operation.  Until the copy operation completes,
+     * no other database operation may be performed.
+     * Implemented for protocol version 3 only.
+     * @throws SQLException when initializing the given query fails
+     */
+    CopyOperation startCopy(String sql, boolean suppressBegin) throws SQLException;
+}

=== added file 'src/org/postgresql/driver/core/ResultCursor.java'
--- src/org/postgresql/driver/core/ResultCursor.java	1970-01-01 00:00:00 +0000
+++ src/org/postgresql/driver/core/ResultCursor.java	2011-08-30 20:30:24 +0000
@@ -0,0 +1,40 @@
+/*****************************************************************************
+ * Copyright (C) 2008 EnterpriseDB Corporation.
+ * Copyright (C) 2011 Stado Global Development Group.
+ *
+ * This file is part of Stado.
+ *
+ * Stado is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.