Source code: postgresql/jdbc2/DatabaseMetaData.java

   package postgresql.jdbc2;
   
   // IMPORTANT NOTE: This file implements the JDBC 2 version of the driver.
   // If you make any modifications to this file, you must make sure that the
   // changes are also made (if relevent) to the related JDBC 1 class in the
   // postgresql.jdbc1 package.
   
   import java.sql.*;
   import java.util.*;
  import postgresql.Field;
  
  /**
   * This class provides information about the database as a whole.
   *
   * <p>Many of the methods here return lists of information in ResultSets.  You
   * can use the normal ResultSet methods such as getString and getInt to 
   * retrieve the data from these ResultSets.  If a given form of metadata is
   * not available, these methods should throw a SQLException.
   *
   * <p>Some of these methods take arguments that are String patterns.  These
   * arguments all have names such as fooPattern.  Within a pattern String,
   * "%" means match any substring of 0 or more characters, and "_" means
   * match any one character.  Only metadata entries matching the search
   * pattern are returned.  if a search pattern argument is set to a null
   * ref, it means that argument's criteria should be dropped from the
   * search.
   *
   * <p>A SQLException will be throws if a driver does not support a meta
   * data method.  In the case of methods that return a ResultSet, either
   * a ResultSet (which may be empty) is returned or a SQLException is
   * thrown.
   *
   * @see java.sql.DatabaseMetaData
   */
  public class DatabaseMetaData implements java.sql.DatabaseMetaData 
  {
    Connection connection;    // The connection association
    
    // These define various OID's. Hopefully they will stay constant.
    static final int iVarcharOid = 1043;  // OID for varchar
    static final int iBoolOid = 16;  // OID for bool
    static final int iInt2Oid = 21;  // OID for int2
    static final int iInt4Oid = 23;  // OID for int4
    static final int VARHDRSZ =  4;  // length for int4
    
    // This is a default value for remarks
    private static final byte defaultRemarks[]="no remarks".getBytes();
    
    public DatabaseMetaData(Connection conn)
    {
      this.connection = conn;
    }
    
    /**
     * Can all the procedures returned by getProcedures be called
     * by the current user?
     *
     * @return true if so
     * @exception SQLException if a database access error occurs
     */
    public boolean allProceduresAreCallable() throws SQLException
    {
      return true;    // For now...
    }
    
    /**
     * Can all the tables returned by getTable be SELECTed by
     * the current user?
     *
     * @return true if so
     * @exception SQLException if a database access error occurs
     */
    public boolean allTablesAreSelectable() throws SQLException
    {
      return true;    // For now...
    }
    
    /**
     * What is the URL for this database?
     *
     * @return the url or null if it cannott be generated
     * @exception SQLException if a database access error occurs
     */
    public String getURL() throws SQLException
    {
      return connection.getURL();
    }
    
    /**
     * What is our user name as known to the database?
     *
     * @return our database user name
     * @exception SQLException if a database access error occurs
     */
    public String getUserName() throws SQLException
    {
      return connection.getUserName();
    }
    
   /**
    * Is the database in read-only mode?
    *
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean isReadOnly() throws SQLException
   {
     return connection.isReadOnly();
   }
   
   /**
    * Are NULL values sorted high?
    *
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean nullsAreSortedHigh() throws SQLException
   {
     return false;
   }
   
   /**
    * Are NULL values sorted low?
    *
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean nullsAreSortedLow() throws SQLException
   {
     return false;
   }
   
   /**
    * Are NULL values sorted at the start regardless of sort order?
    *
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean nullsAreSortedAtStart() throws SQLException
   {
     return false;
   }
   
   /**
    * Are NULL values sorted at the end regardless of sort order?
    *
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean nullsAreSortedAtEnd() throws SQLException
   {
     return true;
   }
   
   /**
    * What is the name of this database product - we hope that it is
    * PostgreSQL, so we return that explicitly.
    *
    * @return the database product name
    * @exception SQLException if a database access error occurs
    */
   public String getDatabaseProductName() throws SQLException
   {
     return new String("PostgreSQL");
   }
   
   /**
    * What is the version of this database product.
    *
    * <p>Note that PostgreSQL 6.3 has a system catalog called pg_version - 
    * however, select * from pg_version on any database retrieves
    * no rows.
    *
    * <p>For now, we will return the version 6.3 (in the hope that we change
    * this driver as often as we change the database)
    *
    * @return the database version
    * @exception SQLException if a database access error occurs
    */
   public String getDatabaseProductVersion() throws SQLException
   {
     return ("6.5.2");
   }
   
   /**
    * What is the name of this JDBC driver?  If we don't know this
    * we are doing something wrong!
    *
    * @return the JDBC driver name
    * @exception SQLException why?
    */
   public String getDriverName() throws SQLException
   {
     return new String("PostgreSQL Native Driver");
   }
   
   /**
    * What is the version string of this JDBC driver?  Again, this is
    * static.
    *
    * @return the JDBC driver name.
    * @exception SQLException why?
    */
   public String getDriverVersion() throws SQLException
   {
     return new String(Integer.toString(connection.this_driver.getMajorVersion())+"."+Integer.toString(connection.this_driver.getMinorVersion()));
   }
   
   /**
    * What is this JDBC driver's major version number?
    *
    * @return the JDBC driver major version
    */
   public int getDriverMajorVersion()
   {
     return connection.this_driver.getMajorVersion();
   }
   
   /**
    * What is this JDBC driver's minor version number?
    *
    * @return the JDBC driver minor version
    */
   public int getDriverMinorVersion()
   {
     return connection.this_driver.getMinorVersion();
   }
   
   /**
    * Does the database store tables in a local file?  No - it
    * stores them in a file on the server.
    * 
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean usesLocalFiles() throws SQLException
   {
     return false;
   }
   
   /**
    * Does the database use a file for each table?  Well, not really,
    * since it doesnt use local files. 
    *
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean usesLocalFilePerTable() throws SQLException
   {
     return false;
   }
   
   /**
    * Does the database treat mixed case unquoted SQL identifiers
    * as case sensitive and as a result store them in mixed case?
    * A JDBC-Compliant driver will always return false.
    *
    * <p>Predicament - what do they mean by "SQL identifiers" - if it
    * means the names of the tables and columns, then the answers
    * given below are correct - otherwise I don't know.
    *
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean supportsMixedCaseIdentifiers() throws SQLException
   {
     return false;
   }
   
   /**
    * Does the database treat mixed case unquoted SQL identifiers as
    * case insensitive and store them in upper case?
    *
    * @return true if so
    */
   public boolean storesUpperCaseIdentifiers() throws SQLException
   {
     return false;
   }
   
   /**
    * Does the database treat mixed case unquoted SQL identifiers as
    * case insensitive and store them in lower case?
    *
    * @return true if so
    */
   public boolean storesLowerCaseIdentifiers() throws SQLException
   {
     return true;
   }
   
   /**
    * Does the database treat mixed case unquoted SQL identifiers as
    * case insensitive and store them in mixed case?
    *
    * @return true if so
    */
   public boolean storesMixedCaseIdentifiers() throws SQLException
   {
     return false;
   }
   
   /**
    * Does the database treat mixed case quoted SQL identifiers as
    * case sensitive and as a result store them in mixed case?  A
    * JDBC compliant driver will always return true. 
    *
    * <p>Predicament - what do they mean by "SQL identifiers" - if it
    * means the names of the tables and columns, then the answers
    * given below are correct - otherwise I don't know.
    *
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean supportsMixedCaseQuotedIdentifiers() throws SQLException
   {
     return true;
   }
   
   /**
    * Does the database treat mixed case quoted SQL identifiers as
    * case insensitive and store them in upper case?
    *
    * @return true if so
    */
   public boolean storesUpperCaseQuotedIdentifiers() throws SQLException
   {
     return false;
   }
   
   /**
    * Does the database treat mixed case quoted SQL identifiers as case
    * insensitive and store them in lower case?
    *
    * @return true if so
    */
   public boolean storesLowerCaseQuotedIdentifiers() throws SQLException
   {
     return false;
   }
   
   /**
    * Does the database treat mixed case quoted SQL identifiers as case
    * insensitive and store them in mixed case?
    *
    * @return true if so
    */
   public boolean storesMixedCaseQuotedIdentifiers() throws SQLException
   {
     return false;
   }
   
   /**
    * What is the string used to quote SQL identifiers?  This returns
    * a space if identifier quoting isn't supported.  A JDBC Compliant
    * driver will always use a double quote character.
    *
    * <p>If an SQL identifier is a table name, column name, etc. then
    * we do not support it.
    *
    * @return the quoting string
    * @exception SQLException if a database access error occurs
    */
   public String getIdentifierQuoteString() throws SQLException
   {
     return null;
   }
   
   /**
    * Get a comma separated list of all a database's SQL keywords that
    * are NOT also SQL92 keywords.
    *
    * <p>Within PostgreSQL, the keywords are found in
    *   src/backend/parser/keywords.c
    *
    * <p>For SQL Keywords, I took the list provided at
    *   <a href="http://web.dementia.org/~shadow/sql/sql3bnf.sep93.txt">
    * http://web.dementia.org/~shadow/sql/sql3bnf.sep93.txt</a>
    * which is for SQL3, not SQL-92, but it is close enough for
    * this purpose.
    *
    * @return a comma separated list of keywords we use
    * @exception SQLException if a database access error occurs
    */
   public String getSQLKeywords() throws SQLException
   {
     return new String("abort,acl,add,aggregate,append,archive,arch_store,backward,binary,change,cluster,copy,database,delimiters,do,extend,explain,forward,heavy,index,inherits,isnull,light,listen,load,merge,nothing,notify,notnull,oids,purge,rename,replace,retrieve,returns,rule,recipe,setof,stdin,stdout,store,vacuum,verbose,version");
   }
   
   public String getNumericFunctions() throws SQLException
   {
     // XXX-Not Implemented
     return "";
   }
   
   public String getStringFunctions() throws SQLException
   {
     // XXX-Not Implemented
     return "";
   }
   
   public String getSystemFunctions() throws SQLException
   {
     // XXX-Not Implemented
     return "";
   }
   
   public String getTimeDateFunctions() throws SQLException
   {
     // XXX-Not Implemented
     return "";
   }
   
   /**
    * This is the string that can be used to escape '_' and '%' in
    * a search string pattern style catalog search parameters
    *
    * @return the string used to escape wildcard characters
    * @exception SQLException if a database access error occurs
    */
   public String getSearchStringEscape() throws SQLException
   {
     return new String("\\");
   }
   
   /**
    * Get all the "extra" characters that can bew used in unquoted
    * identifier names (those beyond a-zA-Z0-9 and _)
    *
    * <p>From the file src/backend/parser/scan.l, an identifier is
    * {letter}{letter_or_digit} which makes it just those listed
    * above.
    *
    * @return a string containing the extra characters
    * @exception SQLException if a database access error occurs
    */
   public String getExtraNameCharacters() throws SQLException
   {
     return new String("");
   }
   
   /**
    * Is "ALTER TABLE" with an add column supported?
    * Yes for PostgreSQL 6.1
    *
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean supportsAlterTableWithAddColumn() throws SQLException
   {
     return true;
   }
   
   /**
    * Is "ALTER TABLE" with a drop column supported?
    * Yes for PostgreSQL 6.1
    *
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean supportsAlterTableWithDropColumn() throws SQLException
   {
     return true;
   }
   
   /**
    * Is column aliasing supported?
    *
    * <p>If so, the SQL AS clause can be used to provide names for
    * computed columns or to provide alias names for columns as
    * required.  A JDBC Compliant driver always returns true.
    *
    * <p>e.g.
    *
    * <br><pre>
    * select count(C) as C_COUNT from T group by C;
    *
    * </pre><br>
    * should return a column named as C_COUNT instead of count(C)
    *
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean supportsColumnAliasing() throws SQLException
   {
     return true;
   }
   
   /**
    * Are concatenations between NULL and non-NULL values NULL?  A
    * JDBC Compliant driver always returns true
    *
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean nullPlusNonNullIsNull() throws SQLException
   {
     return true;
   }
   
   public boolean supportsConvert() throws SQLException
   {
     // XXX-Not Implemented
     return false;
   }
   
   public boolean supportsConvert(int fromType, int toType) throws SQLException
   {
     // XXX-Not Implemented
     return false;
   }
   
   public boolean supportsTableCorrelationNames() throws SQLException
   {
     // XXX-Not Implemented
     return false;
   }
   
   public boolean supportsDifferentTableCorrelationNames() throws SQLException
   {
     // XXX-Not Implemented
     return false;
   }
   
   /**
    * Are expressions in "ORCER BY" lists supported?
    * 
    * <br>e.g. select * from t order by a + b;
    *
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean supportsExpressionsInOrderBy() throws SQLException
   {
     return true;
   }
   
   /**
    * Can an "ORDER BY" clause use columns not in the SELECT?
    * I checked it, and you can't.
    *
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean supportsOrderByUnrelated() throws SQLException
   {
     return false;
   }
   
   /**
    * Is some form of "GROUP BY" clause supported?
    * I checked it, and yes it is.
    *
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean supportsGroupBy() throws SQLException
   {
     return true;
   }
   
   /**
    * Can a "GROUP BY" clause use columns not in the SELECT?
    * I checked it - it seems to allow it
    *
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean supportsGroupByUnrelated() throws SQLException
   {
     return true;
   }
   
   /**
    * Can a "GROUP BY" clause add columns not in the SELECT provided
    * it specifies all the columns in the SELECT?  Does anyone actually
    * understand what they mean here?
    *
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean supportsGroupByBeyondSelect() throws SQLException
   {
     return true;    // For now...
   }
   
   /**
    * Is the escape character in "LIKE" clauses supported?  A
    * JDBC compliant driver always returns true.
    *
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean supportsLikeEscapeClause() throws SQLException
   {
     return true;
   }
   
   /**
    * Are multiple ResultSets from a single execute supported?
    * Well, I implemented it, but I dont think this is possible from
    * the back ends point of view.
    * 
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean supportsMultipleResultSets() throws SQLException
   {
     return false;
   }
   
   /**
    * Can we have multiple transactions open at once (on different
    * connections?)
    * I guess we can have, since Im relying on it.
    *
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean supportsMultipleTransactions() throws SQLException
   {
     return true;
   }
   
   /**
    * Can columns be defined as non-nullable.  A JDBC Compliant driver
    * always returns true.
    *
    * <p>This changed from false to true in v6.2 of the driver, as this
    * support was added to the backend.
    *
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean supportsNonNullableColumns() throws SQLException
   {
     return true;
   }
   
   /**
    * Does this driver support the minimum ODBC SQL grammar.  This
    * grammar is defined at:
    *
    * <p><a href="http://www.microsoft.com/msdn/sdk/platforms/doc/odbc/src/intropr.htm">http://www.microsoft.com/msdn/sdk/platforms/doc/odbc/src/intropr.htm</a>
    *
    * <p>In Appendix C.  From this description, we seem to support the
    * ODBC minimal (Level 0) grammar.
    *
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean supportsMinimumSQLGrammar() throws SQLException
   {
     return true;
   }
   
   /**
    * Does this driver support the Core ODBC SQL grammar.  We need
    * SQL-92 conformance for this.
    *
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean supportsCoreSQLGrammar() throws SQLException
   {
     return false;
   }
   
   /**
    * Does this driver support the Extended (Level 2) ODBC SQL
    * grammar.  We don't conform to the Core (Level 1), so we can't
    * conform to the Extended SQL Grammar.
    *
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean supportsExtendedSQLGrammar() throws SQLException
   {
     return false;
   }
   
   /**
    * Does this driver support the ANSI-92 entry level SQL grammar?
    * All JDBC Compliant drivers must return true.  I think we have
    * to support outer joins for this to be true.
    *
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean supportsANSI92EntryLevelSQL() throws SQLException
   {
     return false;
   }
   
   /**
    * Does this driver support the ANSI-92 intermediate level SQL
    * grammar?  Anyone who does not support Entry level cannot support
    * Intermediate level.
    *
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean supportsANSI92IntermediateSQL() throws SQLException
   {
     return false;
   }
   
   /**
    * Does this driver support the ANSI-92 full SQL grammar?
    *
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean supportsANSI92FullSQL() throws SQLException
   {
     return false;
   }
   
   /**
    * Is the SQL Integrity Enhancement Facility supported?
    * I haven't seen this mentioned anywhere, so I guess not
    * 
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean supportsIntegrityEnhancementFacility() throws SQLException
   {
     return false;
   }
   
   /**
    * Is some form of outer join supported?  From my knowledge, nope.
    *
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean supportsOuterJoins() throws SQLException
   {
     return false;
   }
   
   /**
    * Are full nexted outer joins supported?  Well, we dont support any
    * form of outer join, so this is no as well
    *
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean supportsFullOuterJoins() throws SQLException
   {
     return false;
   }
   
   /**
    * Is there limited support for outer joins?  (This will be true if
    * supportFullOuterJoins is true)
    *
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean supportsLimitedOuterJoins() throws SQLException
   {
     return false;
   }
   
   /**
    * What is the database vendor's preferred term for "schema" - well,
    * we do not provide support for schemas, so lets just use that
    * term.
    *
    * @return the vendor term
    * @exception SQLException if a database access error occurs
    */
   public String getSchemaTerm() throws SQLException
   {
     return new String("Schema");
   }
   
   /**
    * What is the database vendor's preferred term for "procedure" - 
    * I kind of like "Procedure" myself.
    *
    * @return the vendor term
    * @exception SQLException if a database access error occurs
    */
   public String getProcedureTerm() throws SQLException
   {
     return new String("Procedure");
   }
   
   /**
    * What is the database vendor's preferred term for "catalog"? -
    * we dont have a preferred term, so just use Catalog
    *
    * @return the vendor term
    * @exception SQLException if a database access error occurs
    */
   public String getCatalogTerm() throws SQLException
   {
     return new String("Catalog");
   }
   
   /**
    * Does a catalog appear at the start of a qualified table name?
    * (Otherwise it appears at the end).
    *
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean isCatalogAtStart() throws SQLException
   {
     return false;
   }
   
   /**
    * What is the Catalog separator.  Hmmm....well, I kind of like
    * a period (so we get catalog.table definitions). - I don't think
    * PostgreSQL supports catalogs anyhow, so it makes no difference.
    *
    * @return the catalog separator string
    * @exception SQLException if a database access error occurs
    */
   public String getCatalogSeparator() throws SQLException
   {
     // PM Sep 29 97 - changed from "." as we don't support catalogs.
     return new String("");
   }
   
   /**
    * Can a schema name be used in a data manipulation statement?  Nope.
    *
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean supportsSchemasInDataManipulation() throws SQLException
   {
     return false;
   }
   
   /**
    * Can a schema name be used in a procedure call statement?  Nope.
    *
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean supportsSchemasInProcedureCalls() throws SQLException
   {
     return false;
   }
   
   /**
    * Can a schema be used in a table definition statement?  Nope.
    *
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean supportsSchemasInTableDefinitions() throws SQLException
   {
     return false;
   }
   
   /**
    * Can a schema name be used in an index definition statement?
    *
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean supportsSchemasInIndexDefinitions() throws SQLException
   {
     return false;
   }
   
   /**
    * Can a schema name be used in a privilege definition statement?
    *
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean supportsSchemasInPrivilegeDefinitions() throws SQLException
   {
     return false;
   }
   
   /**
    * Can a catalog name be used in a data manipulation statement?
    *
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean supportsCatalogsInDataManipulation() throws SQLException
   {
     return false;
   }
   
   /**
    * Can a catalog name be used in a procedure call statement?
    *
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean supportsCatalogsInProcedureCalls() throws SQLException
   {
     return false;
   }
   
   /**
    * Can a catalog name be used in a table definition statement?
    *
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean supportsCatalogsInTableDefinitions() throws SQLException
   {
     return false;
   }
   
   /**
    * Can a catalog name be used in an index definition?
    *
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean supportsCatalogsInIndexDefinitions() throws SQLException
   {
     return false;
   }
   
   /**
    * Can a catalog name be used in a privilege definition statement?
    *
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean supportsCatalogsInPrivilegeDefinitions() throws SQLException
   {
     return false;
   }
   
   /**
    * We support cursors for gets only it seems.  I dont see a method
    * to get a positioned delete.
    *
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean supportsPositionedDelete() throws SQLException
   {
     return false;      // For now...
   }
   
   /**
    * Is positioned UPDATE supported?
    * 
    * @return true if so
    * @exception SQLException if a database access error occurs
    */
   public boolean supportsPositionedUpdate() throws SQLException
   {
     return false;      // For now...
   }
   
   public boolean supportsSelectForUpdate() throws SQLException
   {
     // XXX-Not Implemented
     return false;
   }
   
   public boolean supportsStoredProcedures() throws SQLException
   {
     // XXX-Not Implemented
     return false;
   }
   
   public boolean supportsSubqueriesInComparisons() throws SQLException
   {
     // XXX-Not Implemented
     return false;
   }
   
   public boolean supportsSubqueriesInExists() throws SQLException
   {
     // XXX-Not Implemented
     return false;
   }
   
   public boolean supportsSubqueriesInIns() throws SQLException
   {
     // XXX-Not Implemented
     return false;
   }
   
   public boolean supportsSubqueriesInQuantifieds() throws SQLException
   {
     // XXX-Not Implemented
     return false;
   }
   
   public boolean supportsCorrelatedSubqueries() throws SQLException
   {
    // XXX-Not Implemented
    return false;
  }
  
  /**
   * Is SQL UNION supported?  Nope.
   *
   * @return true if so
   * @exception SQLException if a database access error occurs
   */
  public boolean supportsUnion() throws SQLException
  {
    return false;
  }
  
  /**
   * Is SQL UNION ALL supported?  Nope.
   *
   * @return true if so
   * @exception SQLException if a database access error occurs
   */
  public boolean supportsUnionAll() throws SQLException
  {
    return false;
  }
  
  /**
   * In PostgreSQL, Cursors are only open within transactions.
   *
   * @return true if so
   * @exception SQLException if a database access error occurs
   */
  public boolean supportsOpenCursorsAcrossCommit() throws SQLException
  {
    return false;
  }
  
  /**
   * Do we support open cursors across multiple transactions?
   *
   * @return true if so
   * @exception SQLException if a database access error occurs
   */
  public boolean supportsOpenCursorsAcrossRollback() throws SQLException
  {
    return false;
  }
  
  /**
   * Can statements remain open across commits?  They may, but
   * this driver cannot guarentee that.  In further reflection.
   * we are talking a Statement object jere, so the answer is
   * yes, since the Statement is only a vehicle to ExecSQL()
   *
   * @return true if they always remain open; false otherwise
   * @exception SQLException if a database access error occurs
   */
  public boolean supportsOpenStatementsAcrossCommit() throws SQLException
  {
    return true;
  }
  
  /**
   * Can statements remain open across rollbacks?  They may, but
   * this driver cannot guarentee that.  In further contemplation,
   * we are talking a Statement object here, so the answer is yes,
   * since the Statement is only a vehicle to ExecSQL() in Connection
   *
   * @return true if they always remain open; false otherwise
   * @exception SQLException if a database access error occurs
   */
  public boolean supportsOpenStatementsAcrossRollback() throws SQLException
  {
    return true;
  }
  
  /**
   * How many hex characters can you have in an inline binary literal
   *
   * @return the max literal length
   * @exception SQLException if a database access error occurs
   */
  public int getMaxBinaryLiteralLength() throws SQLException
  {
    return 0;        // For now...
  }
  
  /**
   * What is the maximum length for a character literal
   * I suppose it is 8190 (8192 - 2 for the quotes)
   *
   * @return the max literal length
   * @exception SQLException if a database access error occurs
   */
  public int getMaxCharLiteralLength() throws SQLException
  {
    return 8190;
  }
  
  /**
   * Whats the limit on column name length.  The description of
   * pg_class would say '32' (length of pg_class.relname) - we
   * should probably do a query for this....but....
   *
   * @return the maximum column name length
   * @exception SQLException if a database access error occurs
   */
  public int getMaxColumnNameLength() throws SQLException
  {
    return 32;
  }
  
  /**
   * What is the maximum number of columns in a "GROUP BY" clause?
   *
   * @return the max number of columns
   * @exception SQLException if a database access error occurs  
   */
  public int getMaxColumnsInGroupBy() throws SQLException
  {
    return getMaxColumnsInTable();
  }
  
  /**
   * What's the maximum number of columns allowed in an index?
   * 6.0 only allowed one column, but 6.1 introduced multi-column
   * indices, so, theoretically, its all of them.
   *
   * @return max number of columns
   * @exception SQLException if a database access error occurs
   */
  public int getMaxColumnsInIndex() throws SQLException
  {
    return getMaxColumnsInTable();
  }
  
  /**
   * What's the maximum number of columns in an "ORDER BY clause?
   * Theoretically, all of them!
   *
   * @return the max columns
   * @exception SQLException if a database access error occurs
   */
  public int getMaxColumnsInOrderBy() throws SQLException
  {
    return getMaxColumnsInTable();
  }
  
  /**
   * What is the maximum number of columns in a "SELECT" list?
   * Theoretically, all of them!
   *
   * @return the max columns
   * @exception SQLException if a database access error occurs
   */
  public int getMaxColumnsInSelect() throws SQLException
  {
    return getMaxColumnsInTable();
  }
  
  /**
   * What is the maximum number of columns in a table? From the
   * create_table(l) manual page...
   *
   * <p>"The new class is created as a heap with no initial data.  A
   * class can have no more than 1600 attributes (realistically,
   * this is limited by the fact that tuple sizes must be less than
   * 8192 bytes)..."
   *
   * @return the max columns
   * @exception SQLException if a database access error occurs
   */
  public int getMaxColumnsInTable() throws SQLException
  {
    return 1600;
  }
  
  /**
   * How many active connection can we have at a time to this
   * database?  Well, since it depends on postmaster, which just
   * does a listen() followed by an accept() and fork(), its
   * basically very high.  Unless the system runs out of processes,
   * it can be 65535 (the number of aux. ports on a TCP/IP system).
   * I will return 8192 since that is what even the largest system
   * can realistically handle,
   *
   * @return the maximum number of connections
   * @exception SQLException if a database access error occurs
   */
  public int getMaxConnections() throws SQLException
  {
    return 8192;
  }
  
  /**
   * What is the maximum cursor name length (the same as all
   * the other F***** identifiers!)
   *
   * @return max cursor name length in bytes
   * @exception SQLException if a database access error occurs
   */
  public int getMaxCursorNameLength() throws SQLException
  {
    return 32;
  }
  
  /**
   * What is the maximum length of an index (in bytes)?  Now, does
   * the spec. mean name of an index (in which case its 32, the 
   * same as a table) or does it mean length of an index element
   * (in which case its 8192, the size of a row) or does it mean
   * the number of rows it can access (in which case it 2^32 - 
   * a 4 byte OID number)?  I think its the length of an index
   * element, personally, so Im setting it to 8192.
   *
   * @return max index length in bytes
   * @exception SQLException if a database access error occurs
   */
  public int getMaxIndexLength() throws SQLException
  {
    return 8192;
  }
  
  public int getMaxSchemaNameLength() throws SQLException
  {
    // XXX-Not Implemented
    return 0;
  }
  
  /**
   * What is the maximum length of a procedure name?
   * (length of pg_proc.proname used) - again, I really
   * should do a query here to get it.
   *
   * @return the max name length in bytes
   * @exception SQLException if a database access error occurs
   */
  public int getMaxProcedureNameLength() throws SQLException
  {
    return 32;
  }
  
  public int getMaxCatalogNameLength() throws SQLException
  {
    // XXX-Not Implemented
    return 0;
  }
  
  /**
   * What is the maximum length of a single row?  (not including
   * blobs).  8192 is defined in PostgreSQL.
   *
   * @return max row size in bytes
   * @exception SQLException if a database access error occurs
   */
  public int getMaxRowSize() throws SQLException
  {
    return 8192;
  }
  
  /**
   * Did getMaxRowSize() include LONGVARCHAR and LONGVARBINARY
   * blobs?  We don't handle blobs yet
   *
   * @return true if so
   * @exception SQLException if a database access error occurs
   */
  public boolean doesMaxRowSizeIncludeBlobs() throws SQLException
  {
    return false;
  }
  
  /**
   * What is the maximum length of a SQL statement?
   *
   * @return max length in bytes
   * @exception SQLException if a database access error occurs
   */
  public int getMaxStatementLength() throws SQLException
  {
    return 8192;
  }
  
  /**
   * How many active statements can we have open at one time to
   * this database?  Basically, since each Statement downloads
   * the results as the query is executed, we can have many.  However,
   * we can only really have one statement per connection going
   * at once (since they are executed serially) - so we return
   * one.
   *
   * @return the maximum
   * @exception SQLException if a database access error occurs
   */
  public int getMaxStatements() throws SQLException
  {
    return 1;
  }
  
  /**
   * What is the maximum length of a table name?  This was found
   * from pg_class.relname length
   *
   * @return max name length in bytes
   * @exception SQLException if a database access error occurs
   */
  public int getMaxTableNameLength() throws SQLException
  {
    return 32;
  }
  
  /**
   * What is the maximum number of tables that can be specified
   * in a SELECT?  Theoretically, this is the same number as the
   * number of tables allowable.  In practice tho, it is much smaller
   * since the number of tables is limited by the statement, we
   * return 1024 here - this is just a number I came up with (being
   * the number of tables roughly of three characters each that you
   * can fit inside a 8192 character buffer with comma separators).
   *
   * @return the maximum
   * @exception SQLException if a database access error occurs
   */
  public int getMaxTablesInSelect() throws SQLException
  {
    return 1024;
  }
  
  /**
   * What is the maximum length of a user name?  Well, we generally
   * use UNIX like user names in PostgreSQL, so I think this would
   * be 8.  However, showing the schema for pg_user shows a length
   * for username of 32.
   *
   * @return the max name length in bytes
   * @exception SQLException if a database access error occurs
   */
  public int getMaxUserNameLength() throws SQLException
  {
    return 32;
  }
  
  
  /**
   * What is the database's default transaction isolation level?  We
   * do not support this, so all transactions are SERIALIZABLE.
   *
   * @return the default isolation level
   * @exception SQLException if a database access error occurs
   * @see Connection
   */
  public int getDefaultTransactionIsolation() throws SQLException
  {
      return Connection.TRANSACTION_READ_COMMITTED;
  }
  
  /**
   * Are transactions supported?  If not, commit and rollback are noops
   * and the isolation level is TRANSACTION_NONE.  We do support
   * transactions.  
   *
   * @return true if transactions are supported
   * @exception SQLException if a database access error occurs
   */
  public boolean supportsTransactions() throws SQLException
  {
    return true;
  }
  
  /**
   * Does the database support the given transaction isolation level?
   * We only support TRANSACTION_SERIALIZABLE and TRANSACTION_READ_COMMITTED
   * 
   * @param level the values are defined in java.sql.Connection
   * @return true if so
   * @exception SQLException if a database access error occurs
   * @see Connection
   */
  public boolean supportsTransactionIsolationLevel(int level) throws SQLException
  {
    if (level == Connection.TRANSACTION_SERIALIZABLE ||
        level == Connection.TRANSACTION_READ_COMMITTED)
      return true;
    else
      return false;
  }
  
  /**
   * Are both data definition and data manipulation transactions 
   * supported?  I checked it, and could not do a CREATE TABLE
   * within a transaction, so I am assuming that we don't
   *
   * @return true if so
   * @exception SQLException if a database access error occurs
   */
  public boolean supportsDataDefinitionAndDataManipulationTransactions() throws SQLException
  {
    return false;
  }
  
  /**
   * Are only data manipulation statements withing a transaction
   * supported?
   *
   * @return true if so
   * @exception SQLException if a database access error occurs
   */
  public boolean supportsDataManipulationTransactionsOnly() throws SQLException
  {
    return true;
  }
  
  /**
   * Does a data definition statement within a transaction force
   * the transaction to commit?  I think this means something like:
   *
   * <p><pre>
   * CREATE TABLE T (A INT);
   * INSERT INTO T (A) VALUES (2);
   * BEGIN;
   * UPDATE T SET A = A + 1;
   * CREATE TABLE X (A INT);
   * SELECT A FROM T INTO X;
   * COMMIT;
   * </pre><p>
   *
   * does the CREATE TABLE call cause a commit?  The answer is no.  
   *
   * @return true if so
   * @exception SQLException if a database access error occurs
   */
  public boolean dataDefinitionCausesTransactionCommit() throws SQLException
  {
    return false;
  }
  
  /**
   * Is a data definition statement within a transaction ignored?
   * It seems to be (from experiment in previous method)
   *
   * @return true if so
   * @exception SQLException if a database access error occurs
   */
  public boolean dataDefinitionIgnoredInTransactions() throws SQLException
  {
    return true;
  }
  
  /**
   * Get a description of stored procedures available in a catalog
   * 
   * <p>Only procedure descriptions matching the schema and procedure
   * name criteria are returned.  They are ordered by PROCEDURE_SCHEM
   * and PROCEDURE_NAME
   *
   * <p>Each procedure description has the following columns:
   * <ol>
   * <li><b>PROCEDURE_CAT</b> String => procedure catalog (may be null)
   * <li><b>PROCEDURE_SCHEM</b> String => procedure schema (may be null)
   * <li><b>PROCEDURE_NAME</b> String => procedure name
   * <li><b>Field 4</b> reserved (make it null)
   * <li><b>Field 5</b> reserved (make it null)
   * <li><b>Field 6</b> reserved (make it null)
   * <li><b>REMARKS</b> String => explanatory comment on the procedure
   * <li><b>PROCEDURE_TYPE</b> short => kind of procedure
   *  <ul>
   *    <li> procedureResultUnknown - May return a result
   *   <li> procedureNoResult - Does not return a result
   *  <li> procedureReturnsResult - Returns a result
   *    </ul>
   * </ol>
   *
   * @param catalog - a catalog name; "" retrieves those without a
   *  catalog; null means drop catalog name from criteria
   * @param schemaParrern - a schema name pattern; "" retrieves those
   *  without a schema - we ignore this parameter
   * @param procedureNamePattern - a procedure name pattern
   * @return ResultSet - each row is a procedure description
   * @exception SQLException if a database access error occurs
   */
  public java.sql.ResultSet getProcedures(String catalog, String schemaPattern, String procedureNamePattern) throws SQLException
  {
    // the field descriptors for the new ResultSet
    Field f[] = new Field[8];
    java.sql.ResultSet r;  // ResultSet for the SQL query that we need to do
    Vector v = new Vector();    // The new ResultSet tuple stuff
    
    byte remarks[] = defaultRemarks;
    
    f[0] = new Field(connection, "PROCEDURE_CAT",   iVarcharOid, 32);
    f[1] = new Field(connection, "PROCEDURE_SCHEM", iVarcharOid, 32);
    f[2] = new Field(connection, "PROCEDURE_NAME",  iVarcharOid, 32);
    f[3] = f[4] = f[5] = null;  // reserved, must be null for now
    f[6] = new Field(connection, "REMARKS",     iVarcharOid, 8192);
    f[7] = new Field(connection, "PROCEDURE_TYPE", iInt2Oid,  2);
    
    // If the pattern is null, then set it to the default
    if(procedureNamePattern==null)
      procedureNamePattern="%";
    
    r = connection.ExecSQL("select proname, proretset from pg_proc where proname like '"+procedureNamePattern.toLowerCase()+"' order by proname");
    
    while (r.next())
      {
  byte[][] tuple = new byte[8][0];
  
  tuple[0] = null;      // Catalog name
  tuple[1] = null;      // Schema name
  tuple[2] = r.getBytes(1);    // Procedure name
  tuple[3] = tuple[4] = tuple[5] = null;  // Reserved
  tuple[6] = remarks;      // Remarks
  
  if (r.getBoolean(2))
    tuple[7] = Integer.toString(java.sql.DatabaseMetaData.procedureReturnsResult).getBytes();
  else
    tuple[7] = Integer.toString(java.sql.DatabaseMetaData.procedureNoResult).getBytes();
  
  v.addElement(tuple);
      }
    return new ResultSet(connection, f, v, "OK", 1);
  }
  
  /**
   * Get a description of a catalog's stored procedure parameters
   * and result columns.
   *
   * <p>Only descriptions matching the schema, procedure and parameter
   * name criteria are returned. They are ordered by PROCEDURE_SCHEM
   * and PROCEDURE_NAME. Within this, the return value, if any, is
   * first. Next are the parameter descriptions in call order. The
   * column descriptions follow in column number order.
   *
   * <p>Each row in the ResultSet is a parameter description or column 
   * description with the following fields:
   * <ol>
   * <li><b>PROCEDURE_CAT</b> String => procedure catalog (may be null)
   * <li><b>PROCEDURE_SCHE</b>M String => procedure schema (may be null)
   * <li><b>PROCEDURE_NAME</b> String => procedure name
   * <li><b>COLUMN_NAME</b> String => column/parameter name
   * <li><b>COLUMN_TYPE</b> Short => kind of column/parameter:
   * <ul><li>procedureColumnUnknown - nobody knows
   * <li>procedureColumnIn - IN parameter
   * <li>procedureColumnInOut - INOUT parameter
   * <li>procedureColumnOut - OUT parameter
   * <li>procedureColumnReturn - procedure return value
   * <li>procedureColumnResult - result column in ResultSet
   * </ul>
   * <li><b>DATA_TYPE</b> short => SQL type from java.sql.Types
   * <li><b>TYPE_NAME</b> String => SQL type name
   * <li><b>PRECISION</b> int => precision
   * <li><b>LENGTH</b> int => length in bytes of data
   * <li><b>SCALE</b> short => scale
   * <li><b>RADIX</b> short => radix
   * <li><b>NULLABLE</b> short => can it contain NULL?
   * <ul><li>procedureNoNulls - does not allow NULL values
   * <li>procedureNullable - allows NULL values
   * <li>procedureNullableUnknown - nullability unknown
   * <li><b>REMARKS</b> String => comment describing parameter/column
   * </ol>
   * @param catalog This is ignored in postgresql, advise this is set to null
   * @param schemaPattern This is ignored in postgresql, advise this is set to null
   * @param procedureNamePattern a procedure name pattern
   * @param columnNamePattern a column name pattern
   * @return each row is a stored procedure parameter or column description
   * @exception SQLException if a database-access error occurs
   * @see #getSearchStringEscape
   */
  // Implementation note: This is required for Borland's JBuilder to work
  public java.sql.ResultSet getProcedureColumns(String catalog, String schemaPattern, String procedureNamePattern, String columnNamePattern) throws SQLException
  {
    if(procedureNamePattern==null)
      procedureNamePattern="%";
    
    if(columnNamePattern==null)
      columnNamePattern="%";
    
    // for now, this returns an empty result set.
    Field f[] = new Field[13];
    ResultSet r;  // ResultSet for the SQL query that we need to do
    Vector v = new Vector();    // The new ResultSet tuple stuff
    
    f[0] = new Field(connection, new String("PROCEDURE_CAT"), iVarcharOid, 32);
    f[1] = new Field(connection, new String("PROCEDURE_SCHEM"), iVarcharOid, 32);
    f[2] = new Field(connection, new String("PROCEDURE_NAME"), iVarcharOid, 32);
    f[3] = new Field(connection, new String("COLUMN_NAME"), iVarcharOid, 32);
    f[4] = new Field(connection, new String("COLUMN_TYPE"), iInt2Oid, 2);
    f[5] = new Field(connection, new String("DATA_TYPE"), iInt2Oid, 2);
    f[6] = new Field(connection, new String("TYPE_NAME"), iVarcharOid, 32);
    f[7] = new Field(connection, new String("PRECISION"), iInt4Oid, 4);
    f[8] = new Field(connection, new String("LENGTH"), iInt4Oid, 4);
    f[9] = new Field(connection, new String("SCALE"), iInt2Oid, 2);
    f[10] = new Field(connection, new String("RADIX"), iInt2Oid, 2);
    f[11] = new Field(connection, new String("NULLABLE"), iInt2Oid, 2);
    f[12] = new Field(connection, new String("REMARKS"), iVarcharOid, 32);
    
    // add query loop here
    
    return new ResultSet(connection, f, v, "OK", 1);
  }
  
  /**
   * Get a description of tables available in a catalog.              
   *
   * <p>Only table descriptions matching the catalog, schema, table
   * name and type criteria are returned. They are ordered by
   * TABLE_TYPE, TABLE_SCHEM and TABLE_NAME.                      
   * 
   * <p>Each table description has the following columns:     
   *
   * <ol>
   * <li><b>TABLE_CAT</b> String => table catalog (may be null)      
   * <li><b>TABLE_SCHEM</b> String => table schema (may be null)         
   * <li><b>TABLE_NAME</b> String => table name
   * <li><b>TABLE_TYPE</b> String => table type. Typical types are "TABLE",
   * "VIEW", "SYSTEM TABLE", "GLOBAL TEMPORARY", "LOCAL
   * TEMPORARY", "ALIAS", "SYNONYM".                             
   * <li><b>REMARKS</b> String => explanatory comment on the table
   * </ol>
   *
   * <p>The valid values for the types parameter are:
   * "TABLE", "INDEX", "LARGE OBJECT", "SEQUENCE", "SYSTEM TABLE" and
   * "SYSTEM INDEX"
   *
   * @param catalog a catalog name; For postgresql, this is ignored, and
   * should be set to null
   * @param schemaPattern a schema name pattern; For postgresql, this is ignored, and
   * should be set to null
   * @param tableNamePattern a table name pattern. For all tables this should be "%"
   * @param types a list of table types to include; null returns
   * all types
   * @return each row is a table description      
   * @exception SQLException if a database-access error occurs.
   */
  public java.sql.ResultSet getTables(String catalog, String schemaPattern, String tableNamePattern, String types[]) throws SQLException
  {
    // Handle default value for types
    if(types==null)
      types = defaultTableTypes;
    
    if(tableNamePattern==null)
      tableNamePattern="%";
    
    // the field descriptors for the new ResultSet
    Field f[] = new Field[5];
    java.sql.ResultSet r;  // ResultSet for the SQL query that we need to do
    Vector v = new Vector();    // The new ResultSet tuple stuff
    
    f[0] = new Field(connection, new String("TABLE_CAT"), iVarcharOid, 32);
    f[1] = new Field(connection, new String("TABLE_SCHEM"), iVarcharOid, 32);
    f[2] = new Field(connection, new String("TABLE_NAME"), iVarcharOid, 32);
    f[3] = n