/FileExtraction/Java_unseen/dlitz_resin/modules/quercus/src/com/caucho/quercus/lib/db/PostgresModule.java
/*
 * Copyright (c) 1998-2011 Caucho Technology -- all rights reserved
 *
 * This file is part of Resin(R) Open Source
 *
 * Each copy or derived work must preserve the copyright notice and this
 * notice unmodified.
 *
 * Resin Open Source 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 2 of the License, or
 * (at your option) any later version.
 *
 * Resin Open Source 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, or any warranty
 * of NON-INFRINGEMENT.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Resin Open Source; if not, write to the
 *
 *   Free Software Foundation, Inc.
 *   59 Temple Place, Suite 330
 *   Boston, MA 02111-1307  USA
 *
 * @author Rodrigo Westrupp
 */

package com.caucho.quercus.lib.db;

import com.caucho.quercus.UnimplementedException;
import com.caucho.quercus.annotation.NotNull;
import com.caucho.quercus.annotation.Optional;
import com.caucho.quercus.annotation.ReturnNullAsFalse;
import com.caucho.quercus.env.*;
import com.caucho.quercus.module.AbstractQuercusModule;
import com.caucho.util.CharBuffer;
import com.caucho.util.L10N;
import com.caucho.util.Log;
import com.caucho.vfs.Path;
import com.caucho.vfs.ReadStream;
import com.caucho.vfs.WriteStream;

import java.io.InputStream;
import java.io.OutputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLWarning;
import java.sql.Statement;
import java.sql.Types;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;

// Do not add new compile dependencies (use reflection instead)
// import org.postgresql.largeobject.*;


/**
 * Quercus postgres routines.
 */
public class PostgresModule extends AbstractQuercusModule {

  private static final Logger log = Log.open(PostgresModule.class);
  private static final L10N L = new L10N(PostgresModule.class);

  public static final int PGSQL_ASSOC = 0x01;
  public static final int PGSQL_NUM = 0x02;
  public static final int PGSQL_BOTH = 0x03;
  public static final int PGSQL_CONNECT_FORCE_NEW = 0x04;
  public static final int PGSQL_CONNECTION_BAD = 0x05;
  public static final int PGSQL_CONNECTION_OK = 0x06;
  public static final int PGSQL_SEEK_SET = 0x07;
  public static final int PGSQL_SEEK_CUR = 0x08;
  public static final int PGSQL_SEEK_END = 0x09;
  public static final int PGSQL_EMPTY_QUERY = 0x0A;
  public static final int PGSQL_COMMAND_OK = 0x0B;
  public static final int PGSQL_TUPLES_OK = 0x0C;
  public static final int PGSQL_COPY_OUT = 0x0D;
  public static final int PGSQL_COPY_IN = 0x0E;
  public static final int PGSQL_BAD_RESPONSE = 0x0F;
  public static final int PGSQL_NONFATAL_ERROR = 0x10;
  public static final int PGSQL_FATAL_ERROR = 0x11;
  public static final int PGSQL_TRANSACTION_IDLE = 0x12;
  public static final int PGSQL_TRANSACTION_ACTIVE = 0x13;
  public static final int PGSQL_TRANSACTION_INTRANS = 0x14;
  public static final int PGSQL_TRANSACTION_INERROR = 0x15;
  public static final int PGSQL_TRANSACTION_UNKNOWN = 0x16;
  public static final int PGSQL_DIAG_SEVERITY = 0x17;
  public static final int PGSQL_DIAG_SQLSTATE = 0x18;
  public static final int PGSQL_DIAG_MESSAGE_PRIMARY = 0x19;
  public static final int PGSQL_DIAG_MESSAGE_DETAIL = 0x20;
  public static final int PGSQL_DIAG_MESSAGE_HINT = 0x21;
  public static final int PGSQL_DIAG_STATEMENT_POSITION = 0x22;
  public static final int PGSQL_DIAG_INTERNAL_POSITION = 0x23;
  public static final int PGSQL_DIAG_INTERNAL_QUERY = 0x24;
  public static final int PGSQL_DIAG_CONTEXT = 0x25;
  public static final int PGSQL_DIAG_SOURCE_FILE = 0x26;
  public static final int PGSQL_DIAG_SOURCE_LINE = 0x27;
  public static final int PGSQL_DIAG_SOURCE_FUNCTION = 0x28;
  public static final int PGSQL_ERRORS_TERSE = 0x29;
  public static final int PGSQL_ERRORS_DEFAULT = 0x2A;
  public static final int PGSQL_ERRORS_VERBOSE = 0x2B;
  public static final int PGSQL_STATUS_LONG = 0x2C;
  public static final int PGSQL_STATUS_STRING = 0x2D;
  public static final int PGSQL_CONV_IGNORE_DEFAULT = 0x2E;
  public static final int PGSQL_CONV_FORCE_NULL = 0x2F;

  /**
   * Constructor
   */
  public PostgresModule()
  {
  }

  /**
   * Returns true for the postgres extension.
   */
  public String []getLoadedExtensions()
  {
    return new String[] { "postgres", "pgsql" };
  }

  /**
   * Returns number of affected records (tuples)
   */
  public static int pg_affected_rows(Env env,
                                     @NotNull PostgresResult result)
  {
    try {
      if (result == null)
        return -1;

      return result.getAffectedRows();
    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return 0;
    }
  }

  /**
   * pg_affected_rows() alias.
   */
  public static int pg_cmdtuples(Env env,
                                 @NotNull PostgresResult result)
  {
    if (result == null)
      return -1;
    
    return pg_affected_rows(env, result);
  }
  
  /**
   * Cancel an asynchronous query
   */
  public static boolean pg_cancel_query(Env env,
                                        @NotNull Postgres conn)
  {
    try {
      if (conn == null)
        return false;
      
      conn.setAsynchronousStatement(null);
      conn.setAsynchronousResult(null);

      return true;
    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return false;
    }
  }

  /**
   * Gets the client encoding
   */
  @ReturnNullAsFalse
  public static String pg_client_encoding(Env env,
                                          @Optional Postgres conn)
  {
    try {
      if (conn == null)
        conn = getConnection(env);

      return conn.getClientEncoding();

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return null;
    }
  }

  /**
   * Closes a PostgreSQL connection
   */
  public static boolean pg_close(Env env,
                                 @Optional Postgres conn)
  {
    try {
      if (conn == null)
        return false;

      if (conn == env.getSpecialValue("caucho.postgres"))
        env.removeSpecialValue("caucho.postgres");

      conn.close(env);

      return true;
    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
    }

    return false;
  }

  /**
   * Open a PostgreSQL connection
   */
  @ReturnNullAsFalse
  public static Postgres pg_connect(Env env,
                                    String connectionString,
                                    @Optional int connectionType)
  {
    try {
      String host = "localhost";
      int port = 5432;
      String dbName = "";
      String userName = "";
      String password = "";

      HashMap<String, String> nameValueMap
        = parseConnectionString(connectionString);

      String value = nameValueMap.get("host");
      if (value != null)
        host = nameValueMap.get("host");
      
      value = nameValueMap.get("port");
      if (value != null) {
        port = 0;
        int len = value.length();
        
        for (int i = 0; i < len; i++) {
          char ch = value.charAt(i);
          
          if ('0' <= ch && ch <= '9')
            port = port * 10 + value.charAt(i) - '0';
          else
            break;
        }
      }
      
      value = nameValueMap.get("dbname");
      if (value != null)
        dbName = value;
      
      value = nameValueMap.get("user");
      if (value != null)
        userName = value;
      
      value = nameValueMap.get("password");
      if (value != null)
        password = value;

      String driver = "org.postgresql.Driver";
      String url = "jdbc:postgresql://" + host + ":" + port + "/" + dbName;

      Postgres postgres
        = new Postgres(
          env, host, userName, password, dbName, port, driver, url);

      if (! postgres.isConnected())
        return null;

      env.setSpecialValue("caucho.postgres", postgres);

      return postgres;

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return null;
    }
  }

  /**
   * Returns the name/value pairs from the postgres connection string.
   */
  private static HashMap<String, String> parseConnectionString(String s)
  {
    HashMap<String, String> map = new HashMap<String, String>();
    
    char ch;
    int len = s.length();
    
    int i = 0;
    
    CharBuffer buffer = new CharBuffer();
    
    while (i < len) {
      buffer.clear();
      
      // skip whitespace
      for (; i < len && Character.isWhitespace(ch = s.charAt(i)); i++) {
      }
      
      // get name
      for (;
           i < len && ! Character.isWhitespace(ch = s.charAt(i))
               && ch != '='; i++) {
        buffer.append(ch);
      }
      
      String name = buffer.toString();
      buffer.clear();
      
      // skip until '='
      while (i < len && (ch = s.charAt(i++)) != '=') {
      }
      
      // skip whitespace
      for (; i < len && Character.isWhitespace(ch = s.charAt(i)); i++) {
      }
      
      boolean isQuoted = false;
      
      // value may be quoted
      if (i < len) {
        if ((ch = s.charAt(i++)) == '\'')
          isQuoted = true;
        else
          buffer.append(ch);
      }
      
      boolean isEscaped = false;
      
      // get value
      loop:
      while (i < len) {
        ch = s.charAt(i++);
        
        switch(ch) {
          case '\\':
            if (isEscaped)
              buffer.append(ch);

            isEscaped = !isEscaped;
            break;
            
          case '\'':
            if (isEscaped) {
              buffer.append(ch);
              isEscaped = false;
              break;
            }
            else if (isQuoted)
              break loop;

          case ' ':
          case '\n':
          case '\r':
          case '\f':
          case '\t':
            if (isQuoted) {
              buffer.append(ch);
              break;
            }
            else if (isEscaped) {
              buffer.append('\\');
              break loop;
            }
            else
              break loop;

          default:
            if (isEscaped) {
              buffer.append('\\');
              isEscaped = false;
            }

            buffer.append(ch);
        }
      }

      String value = buffer.toString();
      
      if (name.length() > 0)
        map.put(name, value);
    }

    return map;
  }
  
  /**
   * Get connection is busy or not
   */
  public static boolean pg_connection_busy(Env env,
                                           @NotNull Postgres conn)
  {
    // Always return false, for now (pg_send_xxxx are not asynchronous)
    // so there should be no reason for a connection to become busy in
    // between different pg_xxx calls.

    return false;
  }

  /**
   * Reset connection (reconnect)
   */
  public static boolean pg_connection_reset(Env env,
                                            @NotNull Postgres conn)
  {
    try {
      if (conn == null)
        return false;

      // Query database name before closing connection

      String dbname = conn.getDbName();

      conn.close(env);

      conn = new Postgres(env,
                          conn.getHost(),
                          conn.getUserName(),
                          conn.getPassword(),
                          dbname,
                          conn.getPort(),
                          conn.getDriver(),
                          conn.getUrl());

      env.setSpecialValue("caucho.postgres", conn);

      return true;

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return false;
    }
  }

  /**
   * Get connection status
   */
  public static int pg_connection_status(Env env,
                                         @NotNull Postgres conn)
  {
    try {
      if (conn == null)
        return PGSQL_CONNECTION_BAD;
      
      boolean ping = pg_ping(env, conn);

      return ping ? PGSQL_CONNECTION_OK : PGSQL_CONNECTION_BAD;

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return PGSQL_CONNECTION_BAD;
    }
  }

  /**
   * Convert associative array values into suitable for SQL statement
   */
  @ReturnNullAsFalse
  public static ArrayValue pg_convert(Env env,
                                      @NotNull Postgres conn,
                                      String tableName,
                                      ArrayValue assocArray,
                                      @Optional("0") int options)
  {
    try {
      if (conn == null)
        return null;

      // XXX: options has not been implemented yet.

      // XXX: the following PHP note has not been implemented yet.
      // Note:  If there are boolean fields in table_name don't use
      // the constant TRUE in assoc_array. It will be converted to the
      // string 'TRUE' which is no valid entry for boolean fields in
      // PostgreSQL. Use one of t, true, 1, y, yes instead.

      if (options > 0) {
        throw new UnimplementedException("pg_convert with options");
      }

      PostgresResult result;

      Connection jdbcConn = conn.getJavaConnection();
      DatabaseMetaData dbMetaData = jdbcConn.getMetaData();

      ResultSet rs = dbMetaData.getColumns("", "", tableName, "");

      // Check column count
      ResultSetMetaData rsMetaData = rs.getMetaData();
      int n = rsMetaData.getColumnCount();
      if (n < assocArray.getSize())
        return null;

      ArrayValueImpl newArray = new ArrayValueImpl();

      // Keep track of column matches: assocArray vs. table columns
      int matches = 0;

      while (rs.next()) {
        // Retrieve the original value to be converted
        String columnName = rs.getString("COLUMN_NAME");
        Value columnNameV = StringValue.create(columnName);
        Value value = assocArray.get(columnNameV);

        // Check for column not passed in
        if (value == UnsetValue.UNSET)
          continue;

        matches++;

        if (value.isNull()) {
          value = StringValue.create("NULL");
          // Add the converted value
          newArray.put(columnNameV, value);
          continue;
        }

        // Retrieve the database column type
        int dataType = rs.getInt("DATA_TYPE");

        // Convert the original value to the database type
        switch (dataType) {
        case Types.BIT:
        case Types.TINYINT:
        case Types.SMALLINT:
        case Types.INTEGER:
        case Types.BIGINT:
          if (value.isLongConvertible()) {
            value = LongValue.create(value.toLong());
          } else {
            StringValue sb = env.createUnicodeBuilder();
            value = sb.append("'").append(value).append("'");
          }
          break;

        case Types.DECIMAL:
        case Types.DOUBLE:
        case Types.FLOAT:
        case Types.NUMERIC:
        case Types.REAL:
          if (value.isDoubleConvertible()) {
            value = DoubleValue.create(value.toDouble());
          } else {
            StringValue sb = env.createUnicodeBuilder();
            value = sb.append("'").append(value).append("'");
          }
          break;

        default:
          StringValue sb = env.createUnicodeBuilder();
          if (value.isNumberConvertible())  {
            value = sb.append(value);
          } else {
            value = sb.append("'").append(value).append("'");
          }
        }

        // Add the converted value
        newArray.put(columnNameV, value);
      }

      rs.close();

      // Check if all columns were consumed. Otherwise, there are
      // wrong column names passed in.
      if (matches < assocArray.getSize()) {
        return null;
      }

      return newArray;

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return null;
    }
  }

  /**
   * Insert records into a table from an array
   */
  public static boolean pg_copy_from(Env env,
                                     @NotNull Postgres conn,
                                     String tableName,
                                     ArrayValue rows,
                                     @Optional("") String delimiter,
                                     @Optional("") String nullAs)
  {
    // XXX delimiter not used?

    try {
      if (conn == null)
        return false;

      // XXX: At the time this was implemented, the JDBC driver
      // did not support SQL COPY operations that could simplify
      // the code below.

      String delimiterRegex;
      if (delimiter.equals("")) {
        delimiter = "\t";
        delimiterRegex = "\\t";
      } else {
        // XXX: even the native php version does not seem to do it very well.
        throw new UnimplementedException(
            "pg_copy_from with non-default delimiter");
      }

      if (nullAs.equals("")) {
        nullAs = "\\N";
      } else {
        // XXX: even the native php version does not seem to do it very well.
        throw new UnimplementedException(
            "pg_copy_from with non-default nullAs");
      }

      ArrayValueImpl array = (ArrayValueImpl) rows;
      int size = array.size();

      String baseInsert = "INSERT INTO " + tableName + " VALUES(";

      StringBuilder sb = new StringBuilder(baseInsert);

      int lenBaseInsert = sb.length();

      for (int i = 0; i < size; i++) {
        // Every line has a new-line '\n' character and
        // possibly many NULL values "\\N". Ex:
        // line =
//         "\\N\tNUMBER1col\t\\N\t\\N\tNUM" +
//             "BER2col\tNUMBER3col\tNUMBER4col\t\\N\n";
        String line = array.get(LongValue.create(i)).toString();
        line = line.substring(0, line.length() - 1);

        // "INSERT INTO " + tableName + " VALUES("
        sb.setLength(lenBaseInsert);

        // Split columns
        String []cols = line.split(delimiterRegex);

        int len = cols.length;

        if (len > 0) {

          len--;

          for (int j = 0; j < len; j++) {
            if (cols[j].equals(nullAs)) {
              sb.append("NULL, ");
            } else {
              sb.append("'");
              sb.append(cols[j]);
              sb.append("', ");
            }
          }

          if (cols[len].equals(nullAs)) {
            sb.append("NULL)");
          } else {
            sb.append("'");
            sb.append(cols[len]);
            sb.append("')");
          }

          // Insert record
          pg_query(env, conn, sb.toString());
        }
      }

      return true;

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return false;
    }
  }

  /**
   * Copy a table to an array
   */
  @ReturnNullAsFalse
  public static ArrayValue pg_copy_to(Env env,
                                      @NotNull Postgres conn,
                                      String tableName,
                                      @Optional("") String delimiter,
                                      @Optional("") String nullAs)
  {
    try {
      if (conn == null)
        return null;

      // XXX: At the time this was implemented, the JDBC driver
      // did not support SQL COPY operations that could simplify
      // the code below.

      // XXX: This should be replaced when @Optional("\t") is fixed.
      if (delimiter.equals("")) {
        delimiter = "\t";
      }

      // XXX: This should be replaced when @Optional("\\N") is fixed.
      // Note: according to php.net, it must be \\N, i.e. the
      // two-character sequence: {'\\', 'N'}
      if (nullAs.equals("")) {
        nullAs = "\\N";
      }

      PostgresResult result = pg_query(env, conn, "SELECT * FROM " + tableName);

      ArrayValueImpl newArray = new ArrayValueImpl();

      Object value;

      int curr = 0;

      while ((value = result.fetchArray(env, PGSQL_NUM)) != null) {

        ArrayValueImpl arr = (ArrayValueImpl) value;
        int count = arr.size();

        StringValue sb = env.createUnicodeBuilder();

        LongValue currValue = LongValue.create(curr);

        for (int i = 0; i < count; i++) {

          if (sb.length() > 0)
            sb.append(delimiter);

          Value v = newArray.get(currValue);

          Value fieldValue = arr.get(LongValue.create(i));

          if (fieldValue instanceof NullValue) {
            sb.append(nullAs);
          } else {
            sb.append(fieldValue.toString());
          }
        }

        // Every line has a new-line character.
        sb.append("\n");

        newArray.put(currValue, sb);

        curr++;
      }

      return newArray;

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return null;
    }
  }

  /**
   * Get the database name
   */
  @ReturnNullAsFalse
  public static String pg_dbname(Env env,
                                 @Optional Postgres conn)
  {
    try {
      if (conn == null)
        conn = getConnection(env);

      return conn.getDbName();

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return null;
    }
  }

  /**
   * Deletes records
   */
  public static boolean pg_delete(Env env,
                                  @NotNull Postgres conn,
                                  String tableName,
                                  ArrayValue assocArray,
                                  @Optional("-1") int options)
  {
    // From php.net: this function is EXPERIMENTAL.
    // This function is EXPERIMENTAL. The behaviour of this function,
    // the name of this function, and anything else
    // documented about this function
    // may change without notice in a future release of PHP.
    // Use this function at your own risk.

    try {
      if (conn == null)
        return false;

      if (options > 0) {
        throw new UnimplementedException("pg_delete with options");
      }

      StringBuilder condition = new StringBuilder();

      boolean isFirst = true;

      for (Map.Entry<Value,Value> entry : assocArray.entrySet()) {
        Value k = entry.getKey();
        Value v = entry.getValue();
        if (isFirst) {
          isFirst = false;
        } else {
          condition.append(" AND ");
        }
        condition.append(k.toString());
        condition.append("='");
        condition.append(v.toString());
        condition.append("'");
      }

      StringBuilder query = new StringBuilder();
      query.append("DELETE FROM ");
      query.append(tableName);
      query.append(" WHERE ");
      query.append(condition);

      pg_query(env, conn, query.toString());

      return true;

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return false;
    }
  }

  /**
   * Sync with PostgreSQL backend
   */
  public static boolean pg_end_copy(Env env,
                                    @Optional Postgres conn)
  {
    env.stub("pg_end_copy");

    return false;
  }

  /**
   * Escape a string for insertion into a bytea field
   */
  @ReturnNullAsFalse
  public static StringValue pg_escape_bytea(Env env,
                                            StringValue data)
  {
    if (data.length() == 0)
      return data;

    try {
      Class cl = Class.forName("org.postgresql.util.PGbytea");

      Method method = cl.getDeclaredMethod(
          "toPGString", new Class[] {byte[].class});

      String s = (String) method.invoke(cl, new Object[] { data.toBytes()});

      return Postgres.pgRealEscapeString(env.createString(s));

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return null;
    }
  }

  /**
   * Escape a string for insertion into a bytea field.
   */
  @ReturnNullAsFalse
  public static StringValue pg_escape_bytea(Env env,
                                            @NotNull Postgres conn,
                                            StringValue data)
  {
    return pg_escape_bytea(env, data);
  }

  /**
   * Escape a string for insertion into a text field
   */
  @ReturnNullAsFalse
  public static StringValue pg_escape_string(Env env,
                                             StringValue data)
  {
    try {
      Postgres conn = getConnection(env);

      if (conn == null)
        return null;

      return conn.realEscapeString(data);

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return null;
    }
  }

  /**
   * Sends a request to execute a prepared statement with given parameters,
   * and waits for the result
   */
  @ReturnNullAsFalse
  public static PostgresResult pg_execute(Env env,
                                          @NotNull Postgres conn,
                                          String stmtName,
                                          ArrayValue params)
  {
    try {
      if (conn == null)
        return null;

      PostgresStatement pstmt = conn.getStatement(stmtName);

      return executeInternal(env, conn, pstmt, params);

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      conn.setResultResource(null);
      return null;
    }
  }

  /**
   * Fetches all rows in a particular result column as an array
   */
  @ReturnNullAsFalse
  public static ArrayValue pg_fetch_all_columns(Env env,
                                                @NotNull PostgresResult result,
                                                @Optional("0") int column)
  {
    try {
      if (result == null)
        return null;

      ArrayValueImpl newArray = new ArrayValueImpl();

      int curr = 0;

      for (ArrayValue row = result.fetchRow(env);
           row != null;
           row = result.fetchRow(env)) {

        newArray.put(LongValue.create(curr++),
                     row.get(LongValue.create(column)));

      }

      if (newArray.getSize() > 0) {
        return newArray;
      }

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
    }

    return null;
  }

  /**
   * Fetches all rows from a result as an array
   */
  @ReturnNullAsFalse
  public static ArrayValue pg_fetch_all(Env env,
                                        @NotNull PostgresResult result)
  {
    try {
      if (result == null)
        return null;

      ArrayValueImpl newArray = new ArrayValueImpl();

      int curr = 0;

      for (ArrayValue row = result.fetchAssoc(env);
           row != null;
           row = result.fetchAssoc(env)) {

        newArray.put(LongValue.create(curr++), row);

      }

      if (newArray.getSize() > 0) {
        return newArray;
      }

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
    }

    return null;
  }

  /**
   * Fetch a row as an array
   */
  @ReturnNullAsFalse
  public static ArrayValue pg_fetch_array(
      Env env,
      @NotNull PostgresResult result,
      @Optional("-1") Value row,
      @Optional("PGSQL_BOTH") int resultType) {
    try {
      if (result == null)
        return null;

      // NOTE: pg_fetch_array has an interesting memory feature.
      // Calls to pg_fetch_array usually return the next row for
      // successive calls. There is an exception though.
      // The first time a NULL row is passed in, the previously
      // returned row is returned again. After that, successive
      // calls return the next row as usual.
      // We set a flag for this. See PostgresResult and php/4342

      if (row.isNull()) {
        if (result.getPassedNullRow()) {
          result.setPassedNullRow();
        } else {
          // Step the cursor back to the previous position
          ResultSet rs = result.getResultSet();
          rs.previous();
        }
      }

      // NOTE: row is of type Value because row is optional and there is
      // only one way to specify that 'row' will not be used:
      //
      // pg_fetch_array(result, NULL, resultType)
      //
      // The resultType will be used above though.
      //
      // For such a case, the marshalling code passes row in as NullValue.NULL
      // If we used 'int row' there would be no way to distinguish row 'zero'
      // from row 'null'.

      if (result == null)
        return  null;

      if (row.isLongConvertible() && row.toInt() >= 0) {
        if (!result.seek(env, row.toInt())) {
          env.warning(L.l("Unable to jump to row {0} on PostgreSQL result",
                          row.toInt()));
          return null;
        }
      }

      return result.fetchArray(env, resultType);

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return null;
    }
  }

  /**
   * Fetch a row as an associative array
   */
  @ReturnNullAsFalse
  public static ArrayValue pg_fetch_assoc(Env env,
                                          @NotNull PostgresResult result,
                                          @Optional("-1") Value row)
  {
    try {
      if (result == null)
        return null;
      
      if (! row.isNull() && row.toInt() >= 0) {
        result.seek(env, row.toInt());
      }

      return result.fetchAssoc(env);

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return null;
    }
  }

  /**
   * Fetch a row as an object
   */
  public static Value pg_fetch_object(Env env,
                                      @NotNull PostgresResult result,
                                      @Optional("-1") Value row,
                                      @Optional int resultType)
  {
    try {
      if (result == null)
        return null;

      //@todo use optional resultType
      if ((row != null) && (!row.equals(NullValue.NULL))
          && (row.toInt() >= 0)) {
        result.seek(env, row.toInt());
      }

      Value resultValue =  result.fetchObject(env);

      // php/430l
      if (resultValue.isNull())
        return BooleanValue.FALSE;
      else
        return resultValue;

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return BooleanValue.FALSE;
    }
  }

  /**
   * Returns values from a result resource
   */
  public static Value pg_fetch_result(Env env,
                                      @NotNull PostgresResult result,
                                      Value row,
                                      @Optional("-1") Value fieldNameOrNumber)
  {
    try {
      if (result == null)
        return null;

      // NOTE: row is of type Value because there is a case where
      // row is optional. In such a case, the row value passed in
      // is actually the field number or field name.

      int rowNumber = -1;

      // Handle the case: optional row with mandatory fieldNameOrNumber.
      if (fieldNameOrNumber.isLongConvertible()
          && (fieldNameOrNumber.toInt() < 0)) {
        fieldNameOrNumber = row;
        rowNumber = -1;
      } else {
        rowNumber = row.toInt();
      }

      if (rowNumber >= 0) {
        result.seek(env, rowNumber);
      }

      Value fetchRow = result.fetchRow(env);

      int fieldNumber = result.getColumnNumber(fieldNameOrNumber, 0);

      return fetchRow.get(LongValue.create(fieldNumber));

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return BooleanValue.FALSE;
    }
  }
  
  /**
   * Returns values from a result resource
   */
  public static Value pg_result(Env env,
                                @NotNull PostgresResult result,
                                Value row,
                                @Optional("-1") Value fieldNameOrNumber)
  {
    return pg_fetch_result(env, result, row, fieldNameOrNumber);
  }

  /**
   * Get a row as an enumerated array
   */
  @ReturnNullAsFalse
  public static ArrayValue pg_fetch_row(Env env,
                                        @NotNull PostgresResult result,
                                        @Optional("-1") Value row)
  {
    try {
      if (result == null)
        return null;

      if (row != null && ! row.equals(NullValue.NULL) && row.toInt() >= 0) {
        result.seek(env, row.toInt());
      }

      return result.fetchRow(env);

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return null;
    }
  }

  /**
   * Test if a field is SQL NULL
   */
  @ReturnNullAsFalse
  public static LongValue pg_field_is_null(
      Env env,
      @NotNull PostgresResult result,
      Value row,
      @Optional("-1") Value fieldNameOrNumber) {
    try {
      if (result == null)
        return null;

      // NOTE: row is of type Value because there is a case where
      // row is optional. In such a case, the row value passed in
      // is actually the field number or field name.

      int rowNumber = -1;

      // Handle the case: optional row with mandatory fieldNameOrNumber.
      if (fieldNameOrNumber.isLongConvertible()
          && (fieldNameOrNumber.toInt() == -1)) {
        fieldNameOrNumber = row;
        rowNumber = -1;
      } else {
        rowNumber = row.toInt();
      }

      if (rowNumber >= 0) {
        if (!result.seek(env, rowNumber)) {
          env.warning(L.l("Unable to jump to row {0} on PostgreSQL result",
                          rowNumber));
          return null;
        }
      }

      int fieldNumber = result.getColumnNumber(fieldNameOrNumber, 0);

      Value field = pg_fetch_result(env,
                                    result,
                                    LongValue.MINUS_ONE,
                                    LongValue.create(fieldNumber));

      if (field == null || field.isNull())
        return LongValue.ONE;
      else
        return LongValue.ZERO;

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return null;
    }
  }

  /**
   * pg_field_is_null() alias.
   */
  @ReturnNullAsFalse
  public static LongValue pg_fieldisnull(
      Env env,
      @NotNull PostgresResult result,
      Value row,
      @Optional("-1") Value fieldNameOrNumber) {
    return pg_field_is_null(env, result, row, fieldNameOrNumber);
  }
  
  /**
   * Returns the name of a field
   */
  public static Value pg_field_name(Env env,
                                    @NotNull PostgresResult result,
                                    int fieldNumber)
  {
    try {
      if (result == null)
        return BooleanValue.FALSE;

      return result.getFieldName(env, fieldNumber);

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return BooleanValue.FALSE;
    }
  }

  /**
   * pg_field_name() alias.
   */
  public static Value pg_fieldname(Env env,
                                   @NotNull PostgresResult result,
                                   int fieldNumber)
  {
    return pg_field_name(env, result, fieldNumber);
  }
  
  /**
   * Returns the field number of the named field
   *
   * @return the field number (0-based) or -1 on error
   */
  public static int pg_field_num(Env env,
                                 @NotNull PostgresResult result,
                                 String fieldName)
  {
    try {
      if (result == null)
        return -1;

      return result.getColumnNumber(fieldName);
    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return -1;
    }
  }

  /**
   * pg_field_num() alias.
   */
  public static int pg_fieldnum(Env env,
                                @NotNull PostgresResult result,
                                String fieldName)
  {
    return pg_field_num(env, result, fieldName);
  }
  
  /**
   * Returns the printed length
   */
  public static int pg_field_prtlen(Env env,
                                    @NotNull PostgresResult result,
                                    Value rowNumber,
                                    @Optional("-1") Value fieldNameOrNumber)
  {
    try {
      if (result == null)
        return -1;
      
      int row = rowNumber.toInt();

      if (fieldNameOrNumber.toString().equals("-1")) {
        fieldNameOrNumber = rowNumber;
        row = -1;
      }

      int fieldNumber = result.getColumnNumber(fieldNameOrNumber, 0);

      ResultSetMetaData metaData = result.getMetaData();
      String typeName = metaData.getColumnTypeName(fieldNumber + 1);
      if (typeName.equals("bool")) {
        return 1;
      }

      Value value = pg_fetch_result(env,
                                    result,
                                    LongValue.create(row),
                                    LongValue.create(fieldNumber));

      // Step the cursor back to the original position
      // See php/430p
      result.getResultSet().previous();

      int len = value.toString().length();

      // XXX: check this...
      // if (typeName.equals("money")) {
      //  len++;
      // }

      return len;

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return -1;
    }
  }

  /**
   * pg_field_ptrlen() alias.
   */
  public static int pg_fieldprtlen(Env env,
                                   @NotNull PostgresResult result,
                                   Value rowNumber,
                                   @Optional("-1") Value fieldNameOrNumber)
  {
    return pg_field_prtlen(env, result, rowNumber, fieldNameOrNumber);
  }
  
  /**
   * Returns the internal storage size of the named field
   */
  @ReturnNullAsFalse
  public static LongValue pg_field_size(Env env,
                                        @NotNull PostgresResult result,
                                        int fieldNumber)
  {
    try {
      if (result == null)
        return LongValue.create(-1);

      ResultSetMetaData metaData = result.getMetaData();

      fieldNumber++;

      int dataType = metaData.getColumnType(fieldNumber);

      int size = -1;

      switch (dataType) {
      case Types.BIT:
        {
          String typeName = metaData.getColumnTypeName(fieldNumber);
          if (typeName.equals("bool")) {
            size = 1;
          }
          break;
        }

      case Types.TINYINT:
        size = 1;
        break;

      case Types.SMALLINT:
        size = 2;
        break;

      case Types.DATE:
      case Types.FLOAT:
      case Types.INTEGER:
      case Types.REAL:
        size = 4;
        break;

      case Types.BIGINT:
      case Types.DOUBLE:
        {
          size = 8;
          String typeName = metaData.getColumnTypeName(fieldNumber);
          if (typeName.equals("money")) {
            size = 4;
          }
        }
        break;

      case Types.TIME:
      case Types.TIMESTAMP:
        size = 8;
        // fall to specific cases

      default:
        {
          String typeName = metaData.getColumnTypeName(fieldNumber);
          if (typeName.equals("timetz")
              || typeName.equals("interval")) {
            size = 12;
          } else if (typeName.equals("macaddr")) {
            size = 6;
          } else if (typeName.equals("point")) {
            size = 16;
          } else if (typeName.equals("circle")) {
            size = 24;
          } else if (typeName.equals("box")
              || typeName.equals("lseg")) {
            size = 32;
          }
        }
      }

      return LongValue.create(size);

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return null;
    }
  }

  /**
   * pg_field_size() alias.
   */
  @ReturnNullAsFalse
  public static LongValue pg_fieldsize(Env env,
                                       @NotNull PostgresResult result,
                                       int fieldNumber)
  {
    return pg_field_size(env, result, fieldNumber);
  }
  
  /**
   * Returns the name or oid of the tables field
   *
   * @return By default the tables name that field belongs to
   * is returned but if oid_only is set to TRUE,
   * then the oid will instead be returned.
   */
  @ReturnNullAsFalse
  public static String pg_field_table(Env env,
                                      @NotNull PostgresResult result,
                                      int fieldNumber,
                                      @Optional("false") boolean oidOnly)
  {
    // The Postgres JDBC driver doesn't have a concept of exposing
    // to the client what table maps to a particular select item
    // in a result set, therefore the driver cannot report anything
    // useful to the caller. Thus the driver always returns "" to
    // ResultSetMetaData.getTableName(fieldNumber+1)

    env.stub("pg_field_table");

    return "";
  }

  /**
   * Returns the type ID (OID) for the corresponding field number
   */
  @ReturnNullAsFalse
  public static LongValue pg_field_type_oid(Env env,
                                            @NotNull PostgresResult result,
                                            int fieldNumber)
  {
    try {
      if (result == null)
        return null;

      ResultSetMetaData metaData = result.getMetaData();

      String columnTypeName = metaData.getColumnTypeName(fieldNumber + 1);

      String metaQuery =
          ("SELECT oid FROM pg_type WHERE typname='" + columnTypeName + "'");

      result = pg_query(env, (Postgres) result.getConnection(), metaQuery);

      Value value = pg_fetch_result(env,
                                    result,
                                    LongValue.MINUS_ONE,
                                    LongValue.ZERO);

      if (value.isLongConvertible()) {
        return LongValue.create(value.toLong());
      }

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
    }

    return null;
  }

  /**
   * Returns the type name for the corresponding field number
   */
  @ReturnNullAsFalse
  public static StringValue pg_field_type(Env env,
                                          @NotNull PostgresResult result,
                                          int fieldNumber)
  {
    try {
      if (result == null)
        return null;

      ResultSetMetaData metaData = result.getMetaData();

      fieldNumber++;

      String typeName = metaData.getColumnTypeName(fieldNumber);

      return (StringValue) StringValue.create(typeName);

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return null;
    }
  }

  /**
   * pg_field_type() alias.
   */
  @ReturnNullAsFalse
  public static StringValue pg_fieldtype(Env env,
                                          @NotNull PostgresResult result,
                                          int fieldNumber)
  {
    return pg_field_type(env, result, fieldNumber);
  }
  
  /**
   * Free result memory
   */
  public static boolean pg_free_result(Env env,
                                       PostgresResult result)
  {
    try {
      if (result == null)
        return true;
      
      result.close();
      
      return true;
    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      
      return true;
    }
  }

  /**
   * pg_free_result() alias.
   */
  public static boolean pg_freeresult(Env env,
                                      PostgresResult result)
  {
    if (result == null)
      return true;
    
    return pg_free_result(env, result);
  }
  
  /**
   * Gets SQL NOTIFY message
   */
  @ReturnNullAsFalse
  public static ArrayValue pg_get_notify(Env env,
                                         @NotNull Postgres conn,
                                         @Optional("-1") int resultType)
  {
    try {
      if (conn == null)
        return null;
      
      if (resultType > 0) {
        throw new UnimplementedException("pg_get_notify with result type");
      }

      // org.postgresql.PGConnection
      Class cl = Class.forName("org.postgresql.PGConnection");

      // public PGNotification[] getNotifications() throws SQLException;
      Method method = cl.getDeclaredMethod("getNotifications", null);

      Connection pgconn = conn.getJavaConnection();

      // getNotifications()
      Object []notifications = (Object[]) method
          .invoke(pgconn, new Object[] {});

      // org.postgresql.PGNotification
      cl = Class.forName("org.postgresql.PGNotification");

      // public String getName();
      Method methodGetName = cl.getDeclaredMethod("getName", null);

      // public int getPID();
      Method methodGetPID = cl.getDeclaredMethod("getPID", null);

      ArrayValueImpl arrayValue = new ArrayValueImpl();

      int n = notifications.length;

      StringValue k;
      LongValue v;

      for (int i = 0; i < n; i++) {
        // getName()
        k = (StringValue) StringValue.create(
            methodGetName.invoke(notifications[i],
                new Object[]{}));
        // getPID()
        v = (LongValue) LongValue.create(
            (Integer) methodGetPID.invoke(notifications[i],
                new Object[]{}));

        arrayValue.put(k, v);
      }

      return arrayValue;

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return null;
    }
  }

  /**
   * Gets the backend's process ID
   */
  public static int pg_get_pid(Env env,
                               @NotNull Postgres conn)
  {
    try {
      if (conn == null)
        return -1;
      
      // @todo create a random string
      String randomLabel = "caucho_pg_get_pid_random_label";

      pg_query(env, conn, "LISTEN " + randomLabel);
      pg_query(env, conn, "NOTIFY " + randomLabel);

      ArrayValue arrayValue = pg_get_notify(env, conn, -1);

      LongValue pid = (LongValue) arrayValue
          .get(StringValue.create(randomLabel));

      return pid.toInt();

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return -1;
    }
  }

  /**
   * Get asynchronous query result
   */
  @ReturnNullAsFalse
  public static PostgresResult pg_get_result(Env env,
                                             @Optional Postgres conn)
  {
    // Three different scenarios for pg_get_result:
    //
    // 1. pg_send_prepare/pg_send_execute - php/431m
    //
    //    pg_send_prepare(
    // $conn, "my_query", 'SELECT * FROM test WHERE data = $1');
    //    $res1 = pg_get_result($conn);
    //
    //    pg_send_execute($conn, "my_query", array("Joe's Widgets"));
    //    $res2 = pg_get_result($conn);
    //
    //    pg_send_execute($conn, "my_query", array("Clothes Clothes Clothes"));
    //    $res3 = pg_get_result($conn);
    //
    // 2. Multiquery with pg_send_query - php/430y
    //
    //    pg_send_query(
    // $conn, "select * from test; select count(*) from test;");
    //
    //    // select * from test
    //    $res = pg_get_result($conn);
    //    $rows = pg_num_rows($res);
    //
    //    // select count(*) from test
    //    $res = pg_get_result($conn);
    //    $rows = pg_num_rows($res);
    //
    // 3. Individual pg_send_query - php/431g
    //
    //    $res = pg_send_query($conn, "select * from test;");
    //    var_dump($res);
    //    $res = pg_get_result($conn);
    //    var_dump($res);
    //
    //    $res = pg_send_query($conn, "select * from doesnotexist;");
    //    var_dump($res);
    //    $res = pg_get_result($conn);
    //    var_dump($res);

    try {
      if (conn == null)
        conn = getConnection(env);

      PostgresResult result = (PostgresResult) conn.getResultResource();

      // 1. pg_send_prepare/pg_send_execute
      if (conn.getAsynchronousStatement() != null) {
        if (conn.getAsynchronousResult() != null) {
          conn.setAsynchronousResult(null);
          return result;
        }
        return null;
      }

      // 2. pg_send_query
      if (conn.getAsynchronousResult() != null) {

        // Check for next result
        // Ex: pg_send_query(
        // $conn, "select * from test; select count(*) from test;");

        Statement stmt = result.getJavaStatement();

        if (stmt.getMoreResults()) {
          result = (PostgresResult) conn.createResult(env, stmt,
                                                      stmt.getResultSet());
        } else {
          // 3. Individual pg_send_query (clean up; no futher results)
          conn.setResultResource(null);
        }
      }

      conn.setAsynchronousResult(result);

      return result;

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return null;
    }
  }

  /**
   * Returns the host name associated with the connection
   */
  @ReturnNullAsFalse
  public static String pg_host(Env env,
                               @Optional Postgres conn)
  {
    try {
      if (conn == null)
        conn = getConnection(env);

      return conn.getHost();

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return null;
    }
  }

  /**
   * Insert array into table
   */
  public static boolean pg_insert(Env env,
                                  @NotNull Postgres conn,
                                  String tableName,
                                  ArrayValue assocArray,
                                  @Optional("-1") int options)
  {
    try {
      if (conn == null)
        return false;

      if (options > 0) {
        throw new UnimplementedException("pg_insert with options");
      }

      StringBuilder names = new StringBuilder();
      StringBuilder values = new StringBuilder();

      boolean isFirst = true;

      for (Map.Entry<Value,Value> entry : assocArray.entrySet()) {
        Value k = entry.getKey();
        Value v = entry.getValue();
        if (isFirst) {
          isFirst = false;
        } else {
          values.append("','");
          names.append(",");
        }
        values.append(v.toString());
        names.append(k.toString());
      }

      StringBuilder query = new StringBuilder();
      query.append("INSERT INTO ");
      query.append(tableName);
      query.append("(");
      query.append(names);
      query.append(") VALUES('");
      query.append(values);
      query.append("')");

      pg_query(env, conn, query.toString());

      return true;

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return false;
    }
  }

  /**
   * Get the last error message string of a connection
   */
  @ReturnNullAsFalse
  public static StringValue pg_last_error(Env env,
                                          @Optional Postgres conn)
  {
    try {

      if (conn == null)
        conn = getConnection(env);

      return conn.error(env);

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return null;
    }
  }
  
  /**
   * pg_last_error() alias.
   */
  @ReturnNullAsFalse
  public static StringValue pg_errormessage(Env env,
                                       @Optional Postgres conn)
  {
    return pg_last_error(env, conn);
  }

  /**
   * Returns the last notice message from PostgreSQL server
   */
  @ReturnNullAsFalse
  public static String pg_last_notice(Env env,
                                      @NotNull Postgres conn)
  {
    try {
      if (conn == null)
        return null;
      
      SQLWarning warning = conn.getWarnings();
      
      if (warning != null)
        return warning.toString();
      else
        return null;

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return null;
    }
  }

  /**
   * Returns the last row's OID
   *
   * Note that:
   * - OID is a unique id. It will not work if the table was
   *   created with "No oid".
   * - MySql's "mysql_insert_id" receives the conection handler as argument but
   * PostgreSQL's "pg_last_oid" uses the result handler.
   */
  @ReturnNullAsFalse
  public static String pg_last_oid(Env env,
                                   PostgresResult result)
  {
    try {

      Statement stmt = result.getJavaStatement();

      Class cl = Class.forName("org.postgresql.jdbc2.AbstractJdbc2Statement");

      Method method = cl.getDeclaredMethod("getLastOID", null);

      int oid = Integer.parseInt(
          method.invoke(stmt, new Object[] {}).toString());

      if (oid > 0)
        return "" + oid;

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
    }

    return null;
  }

  @ReturnNullAsFalse
  public static String pg_getlastoid(Env env,
                                   PostgresResult result)
  {
    return pg_last_oid(env, result);
  }
  
  /**
   * Close a large object
   */
  public static boolean pg_lo_close(Env env,
                                    Object largeObject)
  {
    try {

      Class cl = Class.forName("org.postgresql.largeobject.LargeObject");

      Method method = cl.getDeclaredMethod("close", null);

      method.invoke(largeObject, new Object[] {});
      // largeObject.close();

      return true;

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return false;
    }
  }
  
  /**
   * pg_lo_close() alias.
   */
  public static boolean pg_loclose(Env env,
                                   Object largeObject)
  {
    return pg_lo_close(env, largeObject);
  }

  /**
   * Create a large object
   */
  @ReturnNullAsFalse
  public static LongValue pg_lo_create(Env env,
                                       @Optional Postgres conn)
  {
    try {

      int oid = -1;

      if (conn == null)
        conn = getConnection(env);

      // LargeObjectManager lobManager;
      Object lobManager;

      // org.postgresql.PGConnection
      Class cl = Class.forName("org.postgresql.PGConnection");

      Method method = cl.getDeclaredMethod("getLargeObjectAPI", null);

      Connection pgconn = conn.getJavaConnection();

      // Large Objects may not be used in auto-commit mode.
      pgconn.setAutoCommit(false);

      lobManager = method.invoke(pgconn, new Object[] {});
      // lobManager = ((org.postgresql.PGConnection)conn).getLargeObjectAPI();

      // org.postgresql.largeobject.LargeObjectManager
      cl = Class.forName("org.postgresql.largeobject.LargeObjectManager");

      method = cl.getDeclaredMethod("create", null);

      Object oidObj = method.invoke(lobManager, new Object[] {});

      oid = Integer.parseInt(oidObj.toString());

      // oid = lobManager.create();

      return LongValue.create(oid);

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return null;
    }
  }

  /**
   * pg_lo_create() alias
   */
  @ReturnNullAsFalse
  public static LongValue pg_locreate(Env env,
                                      @Optional Postgres conn)
  {
    return pg_lo_create(env, conn);
  }

  /**
   * Export a large object to a file
   */
  public static boolean pg_lo_export(Env env,
                                     @NotNull Postgres conn,
                                     int oid,
                                     Path path)
  {
    try {
      if (conn == null)
        return false;
      
      //@todo conn should be optional

      // LargeObjectManager lobManager;
      Object lobManager;

      //org.postgresql.largeobject.LargeObjectManager

      Class cl = Class.forName("org.postgresql.PGConnection");

      Method method = cl.getDeclaredMethod("getLargeObjectAPI", null);

      Connection pgconn = conn.getJavaConnection();

      lobManager = method.invoke(pgconn, new Object[] {});
      // lobManager = ((org.postgresql.PGConnection)conn).getLargeObjectAPI();

      cl = Class.forName("org.postgresql.largeobject.LargeObjectManager");

      method = cl.getDeclaredMethod("open", new Class[] {Integer.TYPE});

      Object lobj = method.invoke(lobManager, new Object[] {oid});

      cl = Class.forName("org.postgresql.largeobject.LargeObject");

      method = cl.getDeclaredMethod("getInputStream", null);

      Object isObj = method.invoke(lobj, new Object[] {});

      InputStream is = (InputStream)isObj;

      // Open the file
      WriteStream os = path.openWrite();

      // copy the data from the large object to the file
      os.writeStream(is);

      os.close();
      is.close();

      // Close the large object
      method = cl.getDeclaredMethod("close", null);

      method.invoke(lobj, new Object[] {});

      return true;

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return false;
    }
  }

  /**
   * pg_lo_export() alias.
   */
  public static boolean pg_loexport(Env env,
                                     @NotNull Postgres conn,
                                     int oid,
                                     Path path)
  {
    return pg_lo_export(env, conn, oid, path);
  }
  
  /**
   * Import a large object from file
   */
  @ReturnNullAsFalse
  public static LongValue pg_lo_import(Env env,
                                       @NotNull Postgres conn,
                                       Path path)
  {
    try {
      if (conn == null)
        return null;

      //@todo conn should be optional

      LongValue value = pg_lo_create(env, conn);

      if (value != null) {

        int oid = value.toInt();
        Object largeObject = pg_lo_open(env, conn, oid, "w");

        String data = "";

        // Open the file
        ReadStream is = path.openRead();

        writeLobInternal(largeObject, is, Integer.MAX_VALUE);

        pg_lo_close(env, largeObject);

        is.close();

        return LongValue.create(oid);
      }

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
    }

    return null;
  }

  /**
   * pg_lo_import() alias.
   */
  @ReturnNullAsFalse
  public static LongValue pg_loimport(Env env,
                                      @NotNull Postgres conn,
                                      Path path)
  {
    return pg_lo_import(env, conn, path);
  }
  
  /**
   * Open a large object
   */
  @ReturnNullAsFalse
  public static Object pg_lo_open(Env env,
                                  @NotNull Postgres conn,
                                  int oid,
                                  String mode)
  {
    try {
      if (conn == null)
        return null;

      Object largeObject = null;

      // LargeObjectManager lobManager;
      Object lobManager;

      //org.postgresql.largeobject.LargeObjectManager

      Class cl = Class.forName("org.postgresql.PGConnection");

      Method method = cl.getDeclaredMethod("getLargeObjectAPI", null);

      Connection pgconn = conn.getJavaConnection();

      lobManager = method.invoke(pgconn, new Object[] {});

      cl = Class.forName("org.postgresql.largeobject.LargeObjectManager");

      method = cl.getDeclaredMethod("open",
          new Class[] {Integer.TYPE, Integer.TYPE});

      boolean write = mode.indexOf("w") >= 0;
      boolean read = mode.indexOf("r") >= 0;

      int modeREAD = cl.getDeclaredField("READ").getInt(null);
      int modeREADWRITE = cl.getDeclaredField("READWRITE").getInt(null);
      int modeWRITE = cl.getDeclaredField("WRITE").getInt(null);

      int intMode = modeREAD;

      if (read) {
        if (write) {
          intMode = modeREADWRITE;
        }
      } else if (write) {
        intMode = modeWRITE;
      }

      largeObject = method.invoke(lobManager, new Object[] {oid, intMode});

      return largeObject;

    } catch (Exception ex) {
      env.warning(L.l("Unable to open PostgreSQL large object"));
      log.log(Level.FINE, ex.toString(), ex);
      return null;
    }
  }

  /**
   * pg_lo_open() alias.
   */
  @ReturnNullAsFalse
  public static Object pg_loopen(Env env,
                                 @NotNull Postgres conn,
                                 int oid,
                                 String mode)
  {
    return pg_lo_open(env, conn, oid, mode);
  }
  
  /**
   * Reads an entire large object and send straight to browser
   */
  @ReturnNullAsFalse
  public static LongValue pg_lo_read_all(Env env,
                                         Object largeObject)
  {
    try {
      StringValue contents = pg_lo_read(env, largeObject, -1);
      
      if (contents != null) {
        env.getOut().print(contents);
      }

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
    }

    return null;
  }

  /**
   * pg_lo_read_all() alias.
   */
  @ReturnNullAsFalse
  public static LongValue pg_loreadall(Env env,
                                       Object largeObject)
  {
    return pg_lo_read_all(env, largeObject);
  }
  
  /**
   * Read a large object
   */
  @ReturnNullAsFalse
  public static StringValue pg_lo_read(Env env,
                                       Object largeObject,
                                       @Optional("-1") int len)
  {
    try {

      if (len < 0) {
        len = Integer.MAX_VALUE;
      }

      Class cl = Class.forName("org.postgresql.largeobject.LargeObject");

      Method method = cl.getDeclaredMethod("getInputStream", null);

      InputStream is = (InputStream) method
          .invoke(largeObject, new Object[] {});

      try {
        StringValue bb = env.createBinaryBuilder();

        bb.appendReadAll(is, len);

        return bb;
      } finally {
        is.close();
      }
    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return null;
    }
  }

  /**
   * pg_lo_read() alias.
   */
  @ReturnNullAsFalse
  public static StringValue pg_loread(Env env,
                                      Object largeObject,
                                      @Optional("-1") int len)
  {
    return pg_lo_read(env, largeObject, len);
  }
  
  /**
   * Seeks position within a large object
   */
  public static boolean pg_lo_seek(Env env,
                                   Object largeObject,
                                   int offset,
                                   @Optional int whence)
  {
    try {

      Class cl = Class.forName("org.postgresql.largeobject.LargeObject");

      int seekSET = cl.getDeclaredField("SEEK_SET").getInt(null);
      int seekEND = cl.getDeclaredField("SEEK_END").getInt(null);
      int seekCUR = cl.getDeclaredField("SEEK_CUR").getInt(null);

      switch (whence) {
      case PGSQL_SEEK_SET:
        whence = seekSET;
        break;
      case PGSQL_SEEK_END:
        whence = seekEND;
        break;
      default:
        whence = seekCUR;
      }

      Method method = cl.getDeclaredMethod(
          "seek", new Class[]{Integer.TYPE,Integer.TYPE});

      method.invoke(largeObject, new Object[] {offset, whence});

      return true;

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return false;
    }
  }

  /**
   * Returns current seek position a of large object
   */
  public static int pg_lo_tell(Env env,
                               Object largeObject)
  {
    try {

      Class cl = Class.forName("org.postgresql.largeobject.LargeObject");

      Method method = cl.getDeclaredMethod("tell", null);

      Object obj = method.invoke(largeObject, new Object[] {});

      return Integer.parseInt(obj.toString());

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return -1;
    }
  }

  /**
   * Delete a large object
   */
  public static boolean pg_lo_unlink(Env env,
                                     @NotNull Postgres conn,
                                     int oid)
  {
    try {
      if (conn == null)
        return false;

      // LargeObjectManager lobManager;
      Object lobManager;

      //org.postgresql.largeobject.LargeObjectManager

      Class cl = Class.forName("org.postgresql.PGConnection");

      Method method = cl.getDeclaredMethod("getLargeObjectAPI", null);

      Connection pgconn = conn.getJavaConnection();

      lobManager = method.invoke(pgconn, new Object[] {});

      cl = Class.forName("org.postgresql.largeobject.LargeObjectManager");

      method = cl.getDeclaredMethod("unlink", new Class[] {Integer.TYPE});

      method.invoke(lobManager, new Object[] {oid});

      return true;

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return false;
    }
  }

  /**
   * pg_lo_unlink() alias.
   */
  public static boolean pg_lounlink(Env env,
                                    @NotNull Postgres conn,
                                    int oid)
  {
    return pg_lo_unlink(env, conn, oid);
  }
  
  /**
   * Write to a large object
   */
  @ReturnNullAsFalse
  public static LongValue pg_lo_write(Env env,
                                      @NotNull Object largeObject,
                                      String data,
                                      @Optional int len)
  {
    try {
      if (largeObject == null)
        return null;

      if (len <= 0) {
        len = data.length();
      }

      int written = len;

      Class cl = Class.forName("org.postgresql.largeobject.LargeObject");

      Method method = cl.getDeclaredMethod("write",
                                           new Class[] {byte[].class,
                                                        Integer.TYPE,
                                                        Integer.TYPE});

      method.invoke(largeObject, new Object[] {data.getBytes(), 0, len});

      return LongValue.create(written);

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return null;
    }
  }

  /**
   * pg_lo_write() alias.
   */
  @ReturnNullAsFalse
  public static LongValue pg_lowrite(Env env,
                                     @NotNull Object largeObject,
                                     String data,
                                     @Optional int len)
  {
    return pg_lo_write(env, largeObject, data, len);
  }
  
  /**
   * Get meta data for table
   */
  @ReturnNullAsFalse
  public static ArrayValue pg_meta_data(Env env,
                                        @NotNull Postgres conn,
                                        String tableName)
  {
    env.stub("pg_meta_data");

    return null;
  }

  /**
   * Returns the number of fields in a result
   */
  public static int pg_num_fields(Env env,
                                  @NotNull PostgresResult result)
  {
    try {
      return result.getFieldCount();

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return -1;
    }
  }

  /**
   * pg_num_fields() alias.
   */
  public static int pg_numfields(Env env,
                                 @NotNull PostgresResult result)
  {
    return pg_num_fields(env, result);
  }
  
  /**
   * Returns the number of rows in a result
   */
  public static LongValue pg_num_rows(Env env,
                                      @NotNull PostgresResult result)
  {
    int numRows = -1;

    try {
      if (result == null)
        return LongValue.create(-1);

      if ((result != null) && (result.getResultSet() != null)) {
        numRows = result.getNumRows();
      }

      if (numRows < 0) {
        env.warning(L.l(
            "supplied argument is not a valid PostgreSQL result resource"));
      }

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
    }

    return LongValue.create(numRows);
  }

  /**
   * pg_num_rows() alias.
   */
  public static LongValue pg_numrows(Env env,
                                     @NotNull PostgresResult result)
  {
    return pg_num_rows(env, result);
  }
  
  /**
   * Get the options associated with the connection
   */
  public static String pg_options(Env env,
                                  @Optional Postgres conn)
  {
    throw new UnimplementedException("pg_options");
  }

  /**
   * Looks up a current parameter setting of the server
   */
  public static Value pg_parameter_status(Env env,
                                          @NotNull Postgres conn,
                                          @NotNull StringValue paramName)
  {
    try {
      if (conn == null || paramName == null)
        return BooleanValue.FALSE;

      PostgresResult result = pg_query(env, conn, "SHOW " + paramName);

      Value value = pg_fetch_result(
          env, result, LongValue.ZERO, LongValue.ZERO);

      if (value == null || value.isNull())
        return BooleanValue.FALSE;

      if (paramName.toString().equals("server_encoding")) {
        if (value.equals(env.createString("UNICODE")))
          value = env.createString("UTF8");
      }

      return value;

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return BooleanValue.FALSE;
    }
  }

  /**
   * Looks up a current parameter setting of the server
   */
  public static Value pg_parameter_status(Env env,
                                          @NotNull StringValue paramName)
  {
    Postgres conn = getConnection(env);
    
    return pg_parameter_status(env, conn, paramName);
  }

  /**
   * Open a persistent PostgreSQL connection
   */
  @ReturnNullAsFalse
  public static Postgres pg_pconnect(Env env,
                                     String connectionString,
                                     @Optional int connectType)
  {
    return pg_connect(env, connectionString, connectType);
  }

  /**
   * Ping database connection
   */
  public static boolean pg_ping(Env env,
                                @Optional Postgres conn)
  {
    try {

      if (conn == null)
        conn = getConnection(env);

      return pg_query(env, conn, "SELECT 1") != null;

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return false;
    }
  }

  /**
   * Return the port number associated with the connection
   */
  @ReturnNullAsFalse
  public static StringValue pg_port(Env env,
                                    @Optional Postgres conn)
  {
    try {

      if (conn == null)
        conn = getConnection(env);

      // In PHP, a real pg_port test case returns String

      return (StringValue) StringValue.create(conn.getPort());

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return null;
    }
  }

  /**
   * Submits a request to create a prepared statement with the given parameters,
   * and waits for completion
   */
  @ReturnNullAsFalse
  public static PostgresStatement pg_prepare(Env env,
                                             @NotNull Postgres conn,
                                             String stmtName,
                                             String query)
  {
    try {
      if (conn == null)
        return null;

      PostgresStatement pstmt = conn.prepare(env, env.createString(query));
      conn.putStatement(stmtName, pstmt);
      
      return pstmt;
    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return null;
    }
  }

  /**
   * Send a NULL-terminated string to PostgreSQL backend
   */
  public static boolean pg_put_line(Env env,
                                    @NotNull Postgres conn,
                                    String data)
  {
    try {
      if (conn == null)
        return false;

      Class cl = Class.forName("org.postgresql.core.PGStream");

      Constructor constructor = cl.getDeclaredConstructor(new Class[] {
        String.class, Integer.TYPE});

      Object object = constructor.newInstance(
          new Object[] {conn.getHost(), conn.getPort()});

      byte []dataArray = data.getBytes();

      Method method = cl.getDeclaredMethod("Send", new Class[] {byte[].class});

      method.invoke(object, new Object[] {dataArray});

      return true;

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return false;
    }

  }

  /**
   * Submits a command to the server and waits for the result,
   * with the ability to pass parameters separately from the SQL command text
   */
  @ReturnNullAsFalse
  public static PostgresResult pg_query_params(Env env,
                                               @NotNull Postgres conn,
                                               String query,
                                               ArrayValue params)
  {
    try {
      if (conn == null)
        return null;
      
      if (pg_send_query_params(env, conn, query, params)) {
        return (PostgresResult) conn.getResultResource();
      }

      return null;

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return null;
    }
  }

  /**
   * Execute a query
   */
  @ReturnNullAsFalse
  public static PostgresResult pg_query(Env env, @NotNull String query)
  {
    if (query == null)
      return null;
    
    return pg_query_impl(env, getConnection(env), query, true);
  }

  /**
   * Execute a query
   */
  @ReturnNullAsFalse
  public static PostgresResult pg_query(Env env,
                                        @NotNull Postgres conn,
                                        @NotNull String query)
  {
    if (conn == null || query == null)
      return null;

    return pg_query_impl(env, conn, query, true);
  }

 
  /**
   * pg_query() alias
   */
  @ReturnNullAsFalse
  public static PostgresResult pg_exec(Env env,
                                       @NotNull Postgres conn,
                                       String query)
  {
    if (conn == null)
      return null;
    
    return pg_query(env, conn, query);
  }
  
  /**
   * Execute a query
   */
  private static PostgresResult pg_query_impl(Env env,
                                              Postgres conn,
                                              String query,
                                              boolean reportError)
  {
    try {
      // XXX: the PHP api allows conn to be optional but we
      // totally disallow this case.

      if (conn == null)
        conn = getConnection(env);

      PostgresResult result = conn.query(env, query);

      StringValue error = conn.error(env);

      if (error.length() != 0) {
        if (reportError)
          env.warning(L.l("Query failed: {0}", error));

        return null;
      }

      return result;

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
    }

    return null;
  }

  /**
   * Returns an individual field of an error report
   */
  public static Value pg_result_error_field(Env env,
                                            @NotNull PostgresResult result,
                                            int fieldCode)
  {
    try {
      if (result == null)
        return BooleanValue.FALSE;

      Object errorField = null;

      // Get the postgres specific server error message
      // org.postgresql.util.ServerErrorMessage
      Object serverError = ((Postgres) result
          .getConnection()).getServerErrorMessage();

      if (serverError != null) {
        Class cl = Class.forName("org.postgresql.util.ServerErrorMessage");

        String methodName;

        switch (fieldCode) {
        case PGSQL_DIAG_SEVERITY:
          methodName = "getSeverity";
          break;
        case PGSQL_DIAG_SQLSTATE:
          methodName = "getSQLState";
          break;
        case PGSQL_DIAG_MESSAGE_PRIMARY:
          methodName = "getMessage";
          break;
        case PGSQL_DIAG_MESSAGE_DETAIL:
          methodName = "getDetail";
          break;
        case PGSQL_DIAG_MESSAGE_HINT:
          methodName = "getHint";
          break;
        case PGSQL_DIAG_STATEMENT_POSITION:
          methodName = "getPosition";
          break;
        case PGSQL_DIAG_INTERNAL_POSITION:
          methodName = "getInternalPosition";
          break;
        case PGSQL_DIAG_INTERNAL_QUERY:
          methodName = "getInternalQuery";
          break;
        case PGSQL_DIAG_CONTEXT:
          methodName = "getWhere";
          break;
        case PGSQL_DIAG_SOURCE_FILE:
          methodName = "getFile";
          break;
        case PGSQL_DIAG_SOURCE_LINE:
          methodName = "getLine";
          break;
        case PGSQL_DIAG_SOURCE_FUNCTION:
          methodName = "getRoutine";
          break;
        default:
          return null;
        }

        Method method = cl.getDeclaredMethod(methodName, null);
        errorField = method.invoke(serverError, new Object[] {});
      }

      if (errorField == null) {
        /* XXX: php/431g
        if (fieldCode == PGSQL_DIAG_INTERNAL_QUERY)
          return BooleanValue.FALSE;
        */

        return NullValue.NULL;
      }

      if (fieldCode == PGSQL_DIAG_STATEMENT_POSITION) {

        Integer position = (Integer) errorField;

        if (position.intValue() == 0)
          return NullValue.NULL;
      }

      if (fieldCode == PGSQL_DIAG_INTERNAL_POSITION) {

        Integer position = (Integer) errorField;

        if (position.intValue() == 0)
          // XXX: php/431g return BooleanValue.FALSE;
          return NullValue.NULL;
      }

      return StringValue.create(errorField.toString());

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return NullValue.NULL;
    }
  }

  /**
   * Get error message associated with result
   */
  @ReturnNullAsFalse
  public static String pg_result_error(Env env,
                                       @Optional PostgresResult result)
  {
    try {
      if (result != null)
        return result.getConnection().getErrorMessage();
      else
        return null;
    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return null;
    }
  }

  /**
   * Set internal row offset in result resource
   */
  public static boolean pg_result_seek(Env env,
                                       @NotNull PostgresResult result,
                                       int offset)
  {
    try {
      if (result == null)
        return false;

      return result.seek(env, offset);

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return false;
    }
  }

  /**
   * Get status of query result
   */
  public static int pg_result_status(Env env,
                                     @NotNull PostgresResult result,
                                     @Optional("PGSQL_STATUS_LONG") int type)
  {
    try {
      if (result == null)
        return -1;

      if (type == PGSQL_STATUS_STRING) {
        throw new UnimplementedException(
            "pg_result_status with PGSQL_STATUS_STRING");
      }

      if (result != null) {
        Statement stmt = result.getStatement();
        if (stmt.getUpdateCount() >= 0) {
          return PGSQL_COMMAND_OK;
        }

        ResultSet rs = result.getResultSet();
        if (rs == null) {
          return PGSQL_EMPTY_QUERY;
        }

        return PGSQL_TUPLES_OK;
      }

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
    }

    return -1;
  }

  /**
   * Select records
   */
  @ReturnNullAsFalse
  public static ArrayValue pg_select(Env env,
                                     @NotNull Postgres conn,
                                     String tableName,
                                     ArrayValue assocArray,
                                     @Optional("-1") int options)
  {
    try {
      if (conn == null)
        return null;

      StringValue whereClause = env.createUnicodeBuilder();

      boolean isFirst = true;

      for (Map.Entry<Value,Value> entry : assocArray.entrySet()) {
        Value k = entry.getKey();
        Value v = entry.getValue();
        if (isFirst) {
          isFirst = false;
        } else {
          whereClause.append(" AND ");
        }
        whereClause.append(k.toString()).append("='")
            .append(v.toString()).append("'");
        // String pi = conn.realEscapeString(p).toString();
        // pi = pi.replaceAll("\\\\", "\\\\\\\\");
      }

      StringValue query = env.createUnicodeBuilder();
      query.append("SELECT * FROM ").append(tableName)
          .append(" WHERE ").append(whereClause);

      PostgresResult result = pg_query(env, conn, query.toString());

      return pg_fetch_all(env, result);

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return null;
    }
  }

  /**
   * Sends a request to execute a prepared statement with given parameters,
   * without waiting for the result(s)
   */
  public static boolean pg_send_execute(Env env,
                                        @NotNull Postgres conn,
                                        String stmtName,
                                        ArrayValue params)
  {
    try {

      // Note: for now, this is essentially the same as pg_execute.

      PostgresResult result = pg_execute(env, conn, stmtName, params);

      conn.setAsynchronousResult(result);

      if (result != null) {
        return true;
      }

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
    }

    return false;
  }

  /**
   * Sends a request to create a prepared statement with the given parameters,
   * without waiting for completion
   */
  public static boolean pg_send_prepare(Env env,
                                        @NotNull Postgres conn,
                                        String stmtName,
                                        String query)
  {
    try {

      // Note: for now, this is the same as pg_prepare.

      PostgresStatement stmt = pg_prepare(env, conn, stmtName, query);

      conn.setAsynchronousStatement(stmt);

      if (stmt != null) {
        return true;
      }

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
    }

    return false;
  }

  /**
   * Submits a command and separate parameters to the server
   * without waiting for the result(s)
   */
  public static boolean pg_send_query_params(Env env,
                                             @NotNull Postgres conn,
                                             String query,
                                             ArrayValue params)
  {
    try {

      PostgresStatement pstmt = conn.prepare(env, env.createString(query));

      return executeInternal(env, conn, pstmt, params) != null;

      /*
      ArrayValueImpl arrayImpl = (ArrayValueImpl)params;
      int sz = arrayImpl.size();

      for (int i=0; i<sz; i++) {
        StringValue p = arrayImpl.get(LongValue.create(i)).toStringValue();
        String pi = conn.realEscapeString(p).toString();
        pi = pi.replaceAll("\\\\", "\\\\\\\\");
        query = query.replaceAll("\\$"+(i+1), "\\'"+pi+"\\'");
      }

      pg_send_query(env, conn, query);

      return true;
      */

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return false;
    }
  }

  /**
   * Sends asynchronous query
   */
  public static boolean pg_send_query(Env env,
                                      @NotNull Postgres conn,
                                      String query)
  {
    if (conn == null)
      return false;

    try {
      PostgresResult result = pg_query_impl(env, conn, query, false);

      // We probably won't need this for now. See pg_get_result().
      // conn.setAsynchronousResult(result);

      // php/431g
      // This is to be compliant with real expected results.
      // Even a SELECT * FROM doesnotexist returns true from pg_send_query.
      return true;

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
    }

    return false;
  }

  /**
   * Set the client encoding
   */
  public static int pg_set_client_encoding(Env env,
                                           @NotNull Postgres conn,
                                           String encoding)
  {
    //@todo conn should be optional
    if (conn == null)
      conn = getConnection(env);

    if (conn.setClientEncoding(encoding))
      return 0;
    else
      return -1;
  }

  /**
   * Determines the verbosity of messages returned
   * by pg_last_error() and pg_result_error()
   */
  public static int pg_set_error_verbosity(Env env,
                                           @NotNull Postgres conn,
                                           int intVerbosity)
  {
    try {

      //@todo conn should be optional

      String verbosity;

      PostgresResult result = pg_query(env, conn, "SHOW log_error_verbosity");

      ArrayValue arr = pg_fetch_row(env, result, LongValue.ZERO);

      String prevVerbosity = arr.get(LongValue.ZERO).toString();

      switch (intVerbosity) {
      case PGSQL_ERRORS_TERSE:
        verbosity = "TERSE";
        break;
      case PGSQL_ERRORS_VERBOSE:
        verbosity = "VERBOSE";
        break;
      default:
        verbosity = "DEFAULT";
      }

      pg_query(env, conn, "SET log_error_verbosity TO '" + verbosity + "'");

      if (prevVerbosity.equals("TERSE")) {
        return PGSQL_ERRORS_TERSE;
      } else if (prevVerbosity.equals("VERBOSE")) {
        return PGSQL_ERRORS_VERBOSE;
      } else {
        return PGSQL_ERRORS_DEFAULT;
      }

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return -1;
    }
  }

  /**
   * Enable tracing a PostgreSQL connection
   */
  public static boolean pg_trace(Env env,
                                 Path path,
                                 @Optional String mode,
                                 @Optional Postgres conn)
  {
    env.stub("pg_trace");

    return false;
  }

  /**
   * Returns the current in-transaction status of the server
   */
  public static int pg_transaction_status(Env env,
                                          @Optional Postgres conn)
  {
    return PGSQL_TRANSACTION_IDLE;
  }

  /**
   * Return the TTY name associated with the connection
   */
  public static String pg_tty(Env env,
                              @Optional Postgres conn)
  {
    // Note:  pg_tty() is obsolete, since the server no longer pays attention to
    // the TTY setting, but the function remains for backwards compatibility.

    env.stub("pg_tty");

    return "";
  }

  /**
   * Unescape binary for bytea type
   */
  @ReturnNullAsFalse
  public static String pg_unescape_bytea(Env env,
                                         String data)
  {
    try {

      byte []dataBytes = data.getBytes();

      Class cl = Class.forName("org.postgresql.util.PGbytea");

      Method method = cl.getDeclaredMethod(
          "toBytes", new Class[] {byte[].class});

      return new String((byte[]) method.invoke(cl, new Object[] {dataBytes}));

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return null;
    }
  }

  /**
   * Disable tracing of a PostgreSQL connection
   */
  public static boolean pg_untrace(Env env,
                                   @Optional Postgres conn)
  {
    // Always returns TRUE

    env.stub("pg_untrace");

    return true;
  }

  /**
   * Update table
   */
  public static boolean pg_update(Env env,
                                  @NotNull Postgres conn,
                                  String tableName,
                                  ArrayValue data,
                                  ArrayValue condition,
                                  @Optional int options)
  {
    // From php.net: This function is EXPERIMENTAL.

    // The behaviour of this function, the name of this function, and
    // anything else documented about this function may change without
    // notice in a future release of PHP. Use this function at your own risk.

    try {

      if (options > 0) {
        throw new UnimplementedException("pg_update with options");
      }

      StringBuilder values = new StringBuilder();

      boolean isFirst = true;

      for (Map.Entry<Value,Value> entry : data.entrySet()) {
        Value k = entry.getKey();
        Value v = entry.getValue();
        if (isFirst) {
          isFirst = false;
        } else {
          values.append(", ");
        }
        values.append(k.toString());
        values.append("='");
        values.append(v.toString());
        values.append("'");
      }

      StringBuilder whereClause = new StringBuilder();

      isFirst = true;

      for (Map.Entry<Value,Value> entry : condition.entrySet()) {
        Value k = entry.getKey();
        Value v = entry.getValue();
        if (isFirst) {
          isFirst = false;
        } else {
          whereClause.append(" AND ");
        }
        whereClause.append(k.toString());
        whereClause.append("='");
        whereClause.append(v.toString());
        whereClause.append("'");
      }

      StringBuilder query = new StringBuilder();
      query.append("UPDATE ");
      query.append(tableName);
      query.append(" SET ");
      query.append(values);
      query.append(" WHERE ");
      query.append(whereClause);

      pg_query(env, conn, query.toString());

      return true;

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return false;
    }
  }

  /**
   * Returns an array with client, protocol and server version (when available)
   */
  @ReturnNullAsFalse
  public static ArrayValue pg_version(Env env,
                                      @Optional Postgres conn)
  {
    try {

      //@todo return an array

      if (conn == null)
        conn = (Postgres) env.getSpecialValue("caucho.postgres");

      ArrayValue result = new ArrayValueImpl();

      result.append(env.createString("client"),
                    env.createString(conn.getClientInfo()));
      result.append(env.createString("server_version"),
                    env.createString(conn.getServerInfo()));
      
      return result;
    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return null;
    }
  }

  private static Postgres getConnection(Env env)
  {
    Postgres conn = (Postgres) env.getSpecialValue("caucho.postgres");

    if (conn != null)
      return conn;

    String driver = "org.postgresql.Driver";
    String url = "jdbc:postgresql://localhost:5432/";

    conn = new Postgres(env, "localhost", "", "", "", 5432, driver, url);

    env.setSpecialValue("caucho.postgres", conn);

    return conn;
  }

  private static PostgresResult executeInternal(Env env,
                                                @NotNull Postgres conn,
                                                PostgresStatement pstmt,
                                                ArrayValue params)
  {
    try {

      StringBuilder stringBuilder = new StringBuilder();

      int size = params.getSize(); // pstmt.getPreparedMappingSize();

      for (int i = 0; i < size; i++)
        stringBuilder.append('s');

      String types = stringBuilder.toString();

      Value []value = params.valuesToArray();
      pstmt.bindParams(env, types, value);

      if (!pstmt.execute(env))
        return null;

      if (pstmt.getStatementType().equals("SELECT")) {
        PostgresResult result = new PostgresResult(
            env, null, pstmt.getResultSet(), null);
        conn.setResultResource(result);
        return result;
      } else {
        // XXX: ??? return type?
        return null;
        // return pstmt;
      }

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return null;
    }
  }

  private static int writeLobInternal(Object largeObject,
                                      InputStream is,
                                      int len)
  {
    try {

      Class cl = Class.forName("org.postgresql.largeobject.LargeObject");

      Method method = cl.getDeclaredMethod("getOutputStream", null);

      OutputStream os = (OutputStream) method.invoke(
          largeObject, new Object[] {});

      int written = 0;

      int b;

      while (((b = is.read()) >= 0) && (written++ < len)) {
        os.write(b);
      }

      os.close();

      return written;

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return -1;
    }
  }
}
