path: root/src/interfaces/jdbc/postgresql/DatabaseMetaData.java

package postgresql;

import java.sql.*;

/**
 * @version 1.0 15-APR-1997
 * @author <A HREF="mailto:[email protected]">Adrian Hall</A>
 *
 * This class provides information about the database as a whole.
 *
 * 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.
 *
 * 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.
 *
 * 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

	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.  Note that
	 * PostgreSQL 6.1 has a system catalog called pg_version - 
	 * however, select * from pg_version on any database retrieves
	 * no rows.  For now, we will return the version 6.1 (in the
	 * hopes 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.1");
	}

	/**
	 * 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("1.0");
	}

	/**
	 * What is this JDBC driver's major version number?
	 *
	 * @return the JDBC driver major version
	 */
	public int getDriverMajorVersion()
	{
		return 1;
	}

	/**
	 * What is this JDBC driver's minor version number?
	 *
	 * @return the JDBC driver minor version
	 */
	public int getDriverMinorVersion()
	{
		return 0;
	}

	/**
	 * 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.
	 *
	 * 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 true;
	}

	/**
	 * 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 false;
	}

	/**
	 * 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. 
	 *
	 * 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.
	 *
	 * 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 new String(" ");
	}

	/**
	 * Get a comma separated list of all a database's SQL keywords that
	 * are NOT also SQL92 keywords.
	 *
	 * Within PostgreSQL, the keywords are found in
	 * 	src/backend/parser/keywords.c
	 * For SQL Keywords, I took the list provided at
	 * 	http://web.dementia.org/~shadow/sql/sql3bnf.sep93.txt
	 * 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
	}

	public String getStringFunctions() throws SQLException
	{
		// XXX-Not Implemented
	}

	public String getSystemFunctions() throws SQLException
	{
		// XXX-Not Implemented
	}

	public String getTimeDateFunctions() throws SQLException
	{
		// XXX-Not Implemented
	}

	/**
	 * 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 _)
	 *
	 * 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?
	 *
	 * 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.
	 *
	 * e.g.
	 *
	 * select count(C) as C_COUNT from T group by C;
	 *
	 * 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
	}

	public boolean supportsConvert(int fromType, int toType) throws SQLException
	{
		// XXX-Not Implemented
	}

	public boolean supportsTableCorrelationNames() throws SQLException
	{
		// XXX-Not Implemented
	}

	public boolean supportsDifferentTableCorrelationNames() throws SQLException
	{
		// XXX-Not Implemented
	}

	/**
	 * Are expressions in "ORCER BY" lists supported?
	 * 
	 * 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 false;
	}

	/**
	 * 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.  We dont support NOT NULL, so we are not
	 * JDBC compliant.
	 *
	 * @return true if so
	 * @exception SQLException if a database access error occurs
	 */
	public boolean supportsNonNullableColumns() throws SQLException
	{
		return false;
	}

	/**
	 * Does this driver support the minimum ODBC SQL grammar.  This
	 * grammar is defined at:
	 *
	 * http://www.microsoft.com/msdn/sdk/platforms/doc/odbc/src/intropr.htm
	 *
	 * 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
	{
		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
	}

	public boolean supportsStoredProcedures() throws SQLException
	{
		// XXX-Not Implemented
	}

	public boolean supportsSubqueriesInComparisons() throws SQLException
	{
		// XXX-Not Implemented
	}

	public boolean supportsSubqueriesInExists() throws SQLException
	{
		// XXX-Not Implemented
	}

	public boolean supportsSubqueriesInIns() throws SQLException
	{
		// XXX-Not Implemented
	}

	public boolean supportsSubqueriesInQuantifieds() throws SQLException
	{
		// XXX-Not Implemented
	}

	public boolean supportsCorrelatedSubqueries() throws SQLException
	{
		// XXX-Not Implemented
	}

	/**
	 * 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...
	 *
	 * "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
	}

	/**
	 * 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
	}

	/**
	 * 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_SERIALIZABLE;
	}

	/**
	 * 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
	 * 
	 * @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)
			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:
	 *
	 * 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;
	 *
	 * 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 false;
	}

	/**
	 * Get a description of stored procedures available in a catalog
	 * 
	 * Only procedure descriptions matching the schema and procedure
	 * name criteria are returned.  They are ordered by PROCEDURE_SCHEM
	 * and PROCEDURE_NAME
	 *
	 * Each procedure description has the following columns:
	 * PROCEDURE_CAT String => procedure catalog (may be null)
	 * PROCEDURE_SCHEM String => procedure schema (may be null)
	 * PROCEDURE_NAME String => procedure name
	 * Field 4 reserved (make it null)
	 * Field 5 reserved (make it null)
	 * Field 6 reserved (make it null)
	 * REMARKS String => explanatory comment on the procedure
	 * PROCEDURE_TYPE short => kind of procedure
	 *	* procedureResultUnknown - May return a result
	 * 	* procedureNoResult - Does not return a result
	 *	* procedureReturnsResult - Returns a result
	 *
	 * @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
	{
		Field[] f = new Field[8];		// the field descriptors for the new ResultSet
		static final int iVarcharOid = 1043;	// This is the OID for a varchar()
		static final int iInt2Oid = 21;		// This is the OID for an int2
		ResultSet r;				// ResultSet for the SQL query that we need to do
		Vector v;				// The new ResultSet tuple stuff
		String remarks = new String("no remarks");

		Field[0] = new Field(conn, new String("PROCEDURE_CAT"), iVarcharOid, 32);
		Field[1] = new Field(conn, new String("PROCEDURE_SCHEM"), iVarcharOid, 32);
		Field[2] = new Field(conn, new String("PROCEDURE_NAME"), iVarcharOid, 32);
		Field[3] = null;
		Field[4] = null;
		Field[5] = null;
		Field[6] = new Field(conn, new String("REMARKS"), iVarcharOid, 8192);
		Field[7] = new Field(conn, new String("PROCEDURE_TYPE"), iInt2Oid, 2);
		r = conn.ExecSQL("select proname, proretset from pg_proc order by proname");
		if (r.getColumnCount() != 2 || r.getTupleCount() <= 1)
			throw new SQLException("Unexpected return from query for procedure list");
		while (r.next())
		{
			byte[][] tuple = new byte[8][0];

			String name = r.getString(1);
			String remarks = new String("no remarks");
			boolean retset = r.getBoolean(2);
	
			byte[0] = null;			// Catalog name
			byte[1] = null;			// Schema name
			byte[2] = name.getBytes();	// Procedure name
			byte[3] = null;			// Reserved
			byte[4] = null;			// Reserved
			byte[5] = null;			// Reserved
			byte[6] = remarks.getBytes();	// Remarks
			if (retset)
				byte[7] = procedureReturnsResult;
			else
				byte[7] = procedureNoResult;
			v.addElement(byte);
		}			
		return new ResultSet(conn, f, v, "OK", 1);
	}

	public java.sql.ResultSet getProcedureColumns(String catalog, String schemaPattern, String procedureNamePattern, String columnNamePattern) throws SQLException
	{
		// XXX-Not Implemented
	}

	public java.sql.ResultSet getTables(String catalog, String schemaPattern, String tableNamePattern, String types[]) throws SQLException
	{
		// XXX-Not Implemented
	}

	public java.sql.ResultSet getSchemas() throws SQLException
	{
		// XXX-Not Implemented
	}

	public java.sql.ResultSet getCatalogs() throws SQLException
	{
		// XXX-Not Implemented
	}

	public java.sql.ResultSet getTableTypes() throws SQLException
	{
		// XXX-Not Implemented
	}

	public java.sql.ResultSet getColumns(String catalog, String schemaPattern, String tableNamePattern, String columnNamePattern) throws SQLException
	{
		// XXX-Not Implemented
	}

	public java.sql.ResultSet getColumnPrivileges(String catalog, String schema, String table, String columnNamePattern) throws SQLException
	{
		// XXX-Not Implemented
	}

	public java.sql.ResultSet getTablePrivileges(String catalog, String schemaPattern, String tableNamePattern) throws SQLException
	{
		// XXX-Not Implemented
	}

	public java.sql.ResultSet getBestRowIdentifier(String catalog, String schema, String table, int scope, boolean nullable) throws SQLException
	{
		// XXX-Not Implemented
	}

	public java.sql.ResultSet getVersionColumns(String catalog, String schema, String table) throws SQLException
	{
		// XXX-Not Implemented
	}

	public java.sql.ResultSet getPrimaryKeys(String catalog, String schema, String table) throws SQLException
	{
		// XXX-Not Implemented
	}

	public java.sql.ResultSet getImportedKeys(String catalog, String schema, String table) throws SQLException
	{
		// XXX-Not Implemented
	}

	public java.sql.ResultSet getExportedKeys(String catalog, String schema, String table) throws SQLException
	{
		// XXX-Not Implemented
	}

	public java.sql.ResultSet getCrossReference(String primaryCatalog, String primarySchema, String primaryTable, String foreignCatalog, String foreignSchema, String foreignTable) throws SQLException
	{
		// XXX-Not Implemented
	}

	public java.sql.ResultSet getTypeInfo() throws SQLException
	{
		// XXX-Not Implemented
	}

	public java.sql.ResultSet getIndexInfo(String catalog, String schema, String table, boolean unique, boolean approximate) throws SQLException
	{
		// XXX-Not Implemented
	}
}