Quadcap Embeddable Database

com/quadcap/jdbc/DatabaseMetaData.java

Go to the documentation of this file.

package com.quadcap.jdbc;

/* Copyright 1999 - 2003 Quadcap Software.  All rights reserved.
 *
 * This software is distributed under the Quadcap Free Software License.
 * This software may be used or modified for any purpose, personal or
 * commercial.  Open Source redistributions are permitted.  Commercial
 * redistribution of larger works derived from, or works which bundle
 * this software requires a "Commercial Redistribution License"; see
 * http://www.quadcap.com/purchase.
 *
 * Redistributions qualify as "Open Source" under  one of the following terms:
 *   
 *    Redistributions are made at no charge beyond the reasonable cost of
 *    materials and delivery.
 *
 *    Redistributions are accompanied by a copy of the Source Code or by an
 *    irrevocable offer to provide a copy of the Source Code for up to three
 *    years at the cost of materials and delivery.  Such redistributions
 *    must allow further use, modification, and redistribution of the Source
 *    Code under substantially the same terms as this license.
 *
 * Redistributions of source code must retain the copyright notices as they
 * appear in each source code file, these license terms, and the
 * disclaimer/limitation of liability set forth as paragraph 6 below.
 *
 * Redistributions in binary form must reproduce this Copyright Notice,
 * these license terms, and the disclaimer/limitation of liability set
 * forth as paragraph 6 below, in the documentation and/or other materials
 * provided with the distribution.
 *
 * The Software is provided on an "AS IS" basis.  No warranty is
 * provided that the Software is free of defects, or fit for a
 * particular purpose.  
 *
 * Limitation of Liability. Quadcap Software shall not be liable
 * for any damages suffered by the Licensee or any third party resulting
 * from use of the Software.
 */

import java.io.IOException;

import java.sql.SQLException;

import com.quadcap.sql.Database;
import com.quadcap.sql.Expression;
import com.quadcap.sql.Session;
import com.quadcap.sql.SQLParser;
import com.quadcap.sql.Version;

import com.quadcap.sql.types.ValuePattern;

import com.quadcap.sql.meta.MetaBestRowId;
import com.quadcap.sql.meta.MetaColumns;
import com.quadcap.sql.meta.MetaCrossReference;
import com.quadcap.sql.meta.MetaCursor;
import com.quadcap.sql.meta.MetaIndexInfo;
import com.quadcap.sql.meta.MetaPrimaryKeys;
import com.quadcap.sql.meta.MetaTableTypes;
import com.quadcap.sql.meta.MetaTables;
import com.quadcap.sql.meta.MetaTypes;

/**
 * This class implements the <code>java.sql.DatabaseMetaData</code> interface,
 * which provides a way for the JDBC application to determine which features
 * a database supports and also a way to explore the database schema, through
 * information analagous to the SQL "INFORMATION_SCHEMA".
 *
 * @author Stan Bailes
 */
public class DatabaseMetaData implements java.sql.DatabaseMetaData {
    Database                            database;
    com.quadcap.sql.Connection          qConn;
    Session                             session;
    Connection                          connection;

    DatabaseMetaData(Connection connection) throws IOException, SQLException {
        this.connection = connection;
        this.qConn = connection.getConnection();
        this.session = qConn.createSession();
        this.database = connection.getDatabase();
    }

    /**
     * Return true if the current user has the privileges necessary to
     * invoke all procedures returned by <code>getProcedures()</code>.
     * Since QED doesn't support access privileges,
     * this function always returns false, though since it doesn't support
     * stored procedures, this isn't likely to matter.
     *
     * @return true
     */
    public boolean allProceduresAreCallable() {
        return true;
    }
    
    /**
     * Return true if the current user can use a <code>SELECT</code>
     * statement with all tables returned by <code>getTables()</code>.
     * Since QED doesn't support access privileges, this function always
     * returns true.
     *
     * @return true
     */
    public boolean allTablesAreSelectable() {
        return true;
    }
    
    /**
     * A data definition statement within a transaction does not force
     * a commit in QED.
     *
     * @return false
     */
    public boolean dataDefinitionCausesTransactionCommit() {
        return false;
    }
    
    /**
     * Data definition statements within transactions are not ignored
     * in QED.
     *
     * @return false
     */
    public boolean dataDefinitionIgnoredInTransactions() {
        return false;
    }
    
    /**
     * For all types of ResultSets, deleted rows are simply removed
     * from the ResultSet, so this function always returns false.
     *
     * @return false
     */
    public boolean deletesAreDetected(int type) {
        return false;
    }
    
    /**
     * QED doesn't impose any maximum row size, so this function is
     * really a don't care, but we return true anyway.
     *
     * @return true
     */
    public boolean doesMaxRowSizeIncludeBlobs() {
        return true;
    }
    
    /**
     * Return a resultset containing the set of columns that "best uniquely
     * identify a row".  In QED, this is interpreted to mean the 'primary key'
     * constraint, if specified, otherwise a 'unique' constraint, maybe...
     *
     * @return the specified ResultSet
     * @exception SQLException may be thrown
     */
    public java.sql.ResultSet getBestRowIdentifier(
        String catalog, String schema,  String table, int scope,
        boolean nullable)
        throws SQLException
    {
        StringBuffer sb = new StringBuffer();
        if (schema != null && schema.trim().length() > 0) {
            sb.append(schema.trim());
            sb.append('.');
        }
        if (table != null) sb.append(table);
        MetaBestRowId mt = new MetaBestRowId(session, sb.toString(),
                                             scope, nullable);
        return new ResultSet(mt);
    }
    
    /**
     * QED doesn't support catalogs, so there is no separator.
     *
     * @return the empty string
     */
    public String getCatalogSeparator() {
        return "";
    }
    
    /**
     * Call it what you like, but QED doesn't support catalogs.
     *
     * @return "catalog"
     */
    public String getCatalogTerm() {
        return "catalog";
    }
    
    /**
     * QED doesn't support catalogs, but we return an empty ResultSet
     * of the right signature as a courtesy.
     */
    public java.sql.ResultSet getCatalogs()
        throws SQLException
    {
        return new ResultSet(MetaCursor.find(session, "SYSTEM.CATALOGS"));
    }
    
    /**
     * QED doesn't support access controls, but we return an empty ResultSet
     * of the right signature as a courtesy.
     */
    public java.sql.ResultSet 
    getColumnPrivileges(String catalog, String schema,
                        String table,
                        String columnNamePattern)
        throws SQLException
    {
        return new ResultSet(MetaCursor.find(session,
                                             "SYSTEM.COLUMNPRIVILEGES"));
    }
    
    /**
     * Helper function to handle a single metadata pattern matcher
     */
    final void doPattern(StringBuffer sb, String name, String pattern) {
        if (pattern != null) {
            if (sb.length() > 0) {
                sb.append(" and ");
            }
            sb.append(name);
            sb.append(" like '");
            sb.append(pattern.toUpperCase());
            sb.append('\'');
        }
    }

    /**
     * Helper function to handle a single metadata string specifier
     */
    final void doString(StringBuffer sb, String name, String val) {
        if (val != null) {
            if (sb.length() > 0) {
                sb.append(" and ");
            }
            sb.append(name);
            sb.append(" = '");
            sb.append(val.toUpperCase());
            sb.append('\'');
        }
    }
                                     
    /**
     * This function returns a <code>ResultSet</code> object containing
     * information about the specified columns. 
     *
     * @param catalog not used
     * @param schemaPattern a SQL "like" pattern.  All schema names matching
     *          this pattern are selected.  If this parameter is the empty
     *          string, all schemas are selected.
     * @param tableNamePattern a SQL "like" pattern.  All table names 
     *          matching this pattern are selected.
     * @param columnNamePattern a SQL "like" pattern.  All column names 
     *          matching this pattern are selected.
     * @return a <code>ResultSet</code> object, with each row being a
     *          description of a table column.<p>
     * The columns in the <code>ResultSet</code> object have the
     * following definition:
     *
     * <variablelist>
     * <varlistentry><term>1: TABLE_CAT</term>
     *   <listitem>
     *     <code>null</code> (Catalogs not supported by QED)</listitem>
     * </varlistentry>
     * <varlistentry><term>2: TABLE_SCHEM</term>
     *   <listitem>
     *      <code>String</code> giving the table's schema</listitem>
     * </varlistentry>
     * <varlistentry><term>3: TABLE_NAME</term>
     *   <listitem>
     *     <code>String</code> giving the table's name</listitem>
     * </varlistentry>
     * <varlistentry><term>4: COLUMN_NAME</term>
     *   <listitem>
     *     <code>String</code> giving the column name</listitem>
     * </varlistentry>
     * <varlistentry><term>5: DATA_TYPE</term>
     *   <listitem>
     *     <code>short</code> type from <code>java.sql.types</code></listitem>
     * </varlistentry>
     * <varlistentry><term>6: TYPE_NAME</term>
     *   <listitem>
     *     <code>String</code> giving the SQL type</listitem>
     * </varlistentry>
     * <varlistentry><term>7: COLUMN_SIZE</term>
     *   <listitem>
     *     <code>int</code> For numeric types, this is the precision; 
     *   for character types, it's the maximum width</listitem>
     * </varlistentry>
     * <varlistentry><term>8: BUFFER_LENGTH</term>
     *   <listitem>
     *     <code>null</code> unused</listitem>
     * </varlistentry>
     * <varlistentry><term>9: DECIMAL_DIGITS</term>
     *   <listitem>
     *     <code>int</code> For numeric types, the number of 
     *   digits to the right of the decimal point. 
     *   For other types, <code>-1</code></listitem>
     * </varlistentry>
     * <varlistentry><term>10: NUM_PREC_RADIX</term>
     *   <listitem>
     *     <code>int</code> 10</listitem>
     * </varlistentry>
     * <varlistentry><term>11: NULLABLE</term>
     *   <listitem>
     *     <code>int</code> One of: <ul>
     *    <li><code>ResultSetMetaData.columnNoNulls</code></li>
     *    <li><code>ResultSetMetaData.columnNullable</code></li>
     *    <li><code>ResultSetMetaData.columnNullableUnknown</code>
     *    </li></ul></listitem>
     * </varlistentry>
     * <varlistentry><term>12: REMARKS</term>
     *   <listitem>
     *     <code>null</code></listitem>
     * </varlistentry>
     * <varlistentry><term>13: COLUMN_DEF</term>
     *   <listitem>
     *     <code>String</code> The column's default value, 
     *    cast to a <code>String</code>.  
     *    <code>null</code> if the column doesn't have a default value</listitem>
     * </varlistentry>
     * <varlistentry><term>14: SQL_DATA_TYPE</term>
     *   <listitem>
     *     <code>null</code></listitem>
     * </varlistentry>
     * <varlistentry><term>15: SQL_DATETIME_SUB</term>
     *   <listitem>
     *     <code>null</code></listitem>
     * </varlistentry>
     * <varlistentry><term>16: CHAR_OCTET_LENGTH</term>
     *   <listitem>
     *     <code>int</code> For character types, 
     *    two times the maximum number
     *    of characters in the column.  
     *    <code>null</code> for other types.</listitem>
     * </varlistentry>
     * <varlistentry><term>17: ORDINAL_POSITION</term>
     *   <listitem>
     *     <code>int</code> The index of the column 
     *    in its table.</listitem>
     * </varlistentry>
     * <varlistentry><term>18: IS_NULLABLE</term>
     *   <listitem>
     *     <code>String</code> One of <code>"NO"</code>,
     *    <code>"YES"</code>, or <code>""</code>
     * </listitem>
     * </varlistentry>
     * </variablelist>
     *
     * @exception SQLException may be thrown.
     */
    public java.sql.ResultSet 
    getColumns(String catalog, String schemaPattern,
               String tableNamePattern,
               String columnNamePattern)
        throws SQLException
    {
        if (schemaPattern == null || schemaPattern.equals("")) {
            schemaPattern = null;
        }
        StringBuffer sb = new StringBuffer();
        doPattern(sb, "TABLE_SCHEM", schemaPattern);
        doPattern(sb, "TABLE_NAME", tableNamePattern);
        doPattern(sb, "COLUMN_NAME", columnNamePattern);
        Expression ex = parseExpression(sb.toString());
        MetaColumns mt = new MetaColumns(session, ex);
        return new ResultSet(mt);
    }

    /**
     * Return the <code>Connection</code> object that was used to create this
     * <code>DatabaseMetaData</code> object.
     *
     * @return a Connection object
     */
    public java.sql.Connection getConnection() {
        return connection;
    }
    
    /**
     * This function returns a <code>ResultSet</code> object containing
     * information about the foreign key relationships in the database.
     *
     * @param primaryCatalog not used
     * @param primarySchema a schema name.  Used to specify the schema name
     *          of the table containing the primary key.  <code>null</code>
     *          specifies all schemas.
     * @param foreignCatalog not used
     * @param foreignSchema a schema name.  Used to specify the schema name
     *          of the table containing the foreign key.  <code>null</code>
     *          specifies all schemas.
     * @param foreignTable the name of the table containing the foreign key.
     * @return a <code>ResultSet</code> object, with each row being a
     *          description of a foreign key column.<p>
     * @exception SQLException may be thrown.
     *
     * The columns in the <code>ResultSet</code> object have the following
     * definition:
     * <p>
     * <variablelist>
     * <varlistentry><term>1: PKTABLE_CAT</term>
     *   <listitem>
     *     <code>null</code> (Catalogs not supported by QED)</listitem>
     * </varlistentry>
     * <varlistentry><term>2: PKTABLE_SCHEM</term>
     *   <listitem>
     *      <code>String</code> giving the schema of the 
     *   primary key's table.</listitem>
     * </varlistentry>
     * <varlistentry><term>3: PKTABLE_NAME</term>
     *   <listitem>
     *     <code>String</code> giving the name of the 
     *   primary key's table</listitem>
     * </varlistentry>
     * <varlistentry><term>4: PKCOLUMN_NAME</term>
     *   <listitem>
     *     <code>String</code> giving the column name 
     *   of the primary key</listitem>
     * </varlistentry>
     * <varlistentry><term>5: FKTABLE_CAT</term>
     *   <listitem>
     *     <code>String</code> (An empty string in QED)</listitem>
     * </varlistentry>
     * <varlistentry><term>6: FKTABLE_SCHEM</term>
     *   <listitem>
     *      <code>String</code> giving the schema of 
     *   the foreign key's table.</listitem>
     * </varlistentry>
     * <varlistentry><term>7: FKTABLE_NAME</term>
     *   <listitem>
     *     <code>String</code> giving the name of the 
     *   foreign key's table</listitem>
     * </varlistentry>
     * <varlistentry><term>8: FKCOLUMN_NAME</term>
     *   <listitem>
     *     <code>String</code> giving the column name 
     *   of the foreign key</listitem>
     * </varlistentry>
     * <varlistentry><term>9: KEY_SEQ</term>
     *   <listitem>
     *     <code>short</code> indicating the column number 
     *   within the foreign key, if the foreign key has
     *   more than one column</listitem>
     * </varlistentry>
     * <varlistentry><term>10: UPDATE_RULE</term>
     *   <listitem>
     *     <code>short</code> indicating what happens when the 
     *    primary key is updated:  The values supported by QED
     *    are: <ul>
     *    <li><code>DatabaseMetaData.importedKeyRestrict</code></li>
     *    <li><code>DatabaseMetaData.importedKeyCascade</code></li>
     *    </ul></listitem>
     * </varlistentry>
     * <varlistentry><term>11: DELETE_RULE</term>
     *   <listitem>
     *     <code>short</code> indicating what happens when the 
     *    primary key is deleted:  The values supported by QED
     *    are: <ul>
     *    <li><code>DatabaseMetaData.importedKeyRestrict</code></li>
     *    <li><code>DatabaseMetaData.importedKeyCascade</code></li>
     *    </ul></listitem>
     * </varlistentry>
     * <varlistentry><term>12: FK_NAME</term>
     *   <listitem>
     *     <code>null</code></listitem>
     * </varlistentry>
     * <varlistentry><term>13: PK_NAME</term>
     *   <listitem>
     *     <code>null</code></listitem>
     * </varlistentry>
     * <varlistentry><term>14: DEFERRABILITY</term>
     *   <listitem>
     *     <code>short</code> indicating whether 
     *    foreign key constraint
     *    checking can be deferred.  One of: <ul>
     *    <li><code>DatabaseMetaData.importedKeyInitiallyDeferred</code></li>
     *    <li><code>DatabaseMetaData.importedKeyInitiallyImmediate</code></li>
     *    <li><code>DatabaseMetaData.importedKeyNotDeferrable</code></li>
     *    </ul>
     *    <p>This QED release remembers the deferability specification
     *    in the original DDL statement, but deferred constraint checking
     *    is not supported in this release.
     * 
     * </listitem>
     * </varlistentry>
     * </variablelist>
     */
    public java.sql.ResultSet getCrossReference(String primaryCatalog,
                                                String primarySchema,
                                                String primaryTable,
                                                String foreignCatalog,
                                                String foreignSchema,
                                                String foreignTable)
        throws SQLException
    {
        StringBuffer sb = new StringBuffer();
        doString(sb, "PKTABLE_SCHEM", primarySchema);
        doString(sb, "PKTABLE_NAME", primaryTable);
        doString(sb, "FKTABLE_SCHEM", foreignSchema);
        doString(sb, "FKTABLE_NAME", foreignTable);
        Expression ex = parseExpression(sb.toString());
        MetaCrossReference mx = new MetaCrossReference(session, ex);
        return new ResultSet(mx);
    }
    
    /**
     * Return the database product name, "QED"
     *
     * @return QED
     */
    public String getDatabaseProductName() {
        return "QED";
    }
    
    /**
     * Return the version for this product.  QED version strings are
     * strings of the form <i>major.minor</i>, where <i>major</i>
     * and <i>minor</i> are the driver major and minor version numbers
     *
     * @see #getDriverMajorVersion()
     * @see #getDriverMinorVersion()
     *
     * @return the QED version string.
     */
    public String getDatabaseProductVersion() {
        return "" + getDriverMajorVersion() + "." + getDriverMinorVersion();
    }
    
    /**
     * Return the default transaction isolation level.  For QED, the
     * default (and only supported) transaction isolation level is
     * <code>Connection.TRANSACTION_SERIALIZABLE</code>.
     *
     * @returnt the default transaction isolation level.
     */
    public int getDefaultTransactionIsolation() {
        return Connection.TRANSACTION_SERIALIZABLE;
    }
    
    /**
     * Return the driver major version number.
     *
     * @return the driver's major version number
     */
    public int getDriverMajorVersion() { 
        return Version.majorVersion; 
    }

    /**
     * Return the driver minor version number.
     *
     * @return the driver's minor version number
     */
    public int getDriverMinorVersion() { return Version.minorVersion; }
    
    /**
     * Return the name of this JDBC driver
     *
     * @return the string <code>"com.quadcap.jdbc.JdbcDriver"</code>
     */
    public String getDriverName() {
        return "com.quadcap.jdbc.JdbcDriver";
    }

    /**
     * Return the version for this JDBC Driver.  QED version strings are
     * strings of the form <i>major.minor</i>, where <i>major</i>
     * and <i>minor</i> are the driver major and minor version numbers
     *
     * @see #getDriverMajorVersion()
     * @see #getDriverMinorVersion()
     *
     * @return the QED version string.
     */
    public String getDriverVersion()
        throws SQLException
    {
        return getDatabaseProductVersion();
    }
    
    /**
     * This function returns a <code>ResultSet</code> object that 
     * contains information about the foreign key columns that reference
     * the primary keys in the specified table.
     *
     * @param catalog ignored, since catalogs not supported by QED.
     * @param schema a schema name.  Used to specify the schema name
     *          of the table containing the primary key.  <code>null</code>
     *          specifies any schema.
     * @param table the name of the table containing the primary key.
     * @return a <code>ResultSet</code> object, with each row being a
     *          description of a foreign key column.<p>
     * @exception SQLException may be thrown.
     *
     * The columns in the <code>ResultSet</code> object have the following
     * definition:
     * <p>
     * <variablelist>
     * <varlistentry><term>1: PKTABLE_CAT</term>
     *   <listitem>
     *     <code>null</code> (Catalogs not supported by QED)</listitem>
     * </varlistentry>
     * <varlistentry><term>2: PKTABLE_SCHEM</term>
     *   <listitem>
     *      <code>String</code> giving the schema of the 
     *   primary key's table.</listitem>
     * </varlistentry>
     * <varlistentry><term>3: PKTABLE_NAME</term>
     *   <listitem>
     *     <code>String</code> giving the name of the 
     *   primary key's table</listitem>
     * </varlistentry>
     * <varlistentry><term>4: PKCOLUMN_NAME</term>
     *   <listitem>
     *     <code>String</code> giving the column name 
     *   of the primary key</listitem>
     * </varlistentry>
     * <varlistentry><term>5: FKTABLE_CAT</term>
     *   <listitem>
     *     <code>null</code> (Catalogs not supported by QED)</listitem>
     * </varlistentry>
     * <varlistentry><term>6: FKTABLE_SCHEM</term>
     *   <listitem>
     *      <code>String</code> giving the schema of 
     *   the foreign key's table.</listitem>
     * </varlistentry>
     * <varlistentry><term>7: FKTABLE_NAME</term>
     *   <listitem>
     *     <code>String</code> giving the name of the 
     *   foreign key's table</listitem>
     * </varlistentry>
     * <varlistentry><term>8: FKCOLUMN_NAME</term>
     *   <listitem>
     *     <code>String</code> giving the column name 
     *   of the foreign key</listitem>
     * </varlistentry>
     * <varlistentry><term>9: KEY_SEQ</term>
     *   <listitem>
     *     <code>short</code> indicating the column number 
     *   within the foreign key, if the foreign key has
     *   more than one column</listitem>
     * </varlistentry>
     * <varlistentry><term>10: UPDATE_RULE</term>
     *   <listitem>
     *     <code>short</code> indicating what happens when the 
     *    primary key is updated:  The values supported by QED
     *    are: <ul>
     *    <li><code>DatabaseMetaData.importedKeyRestrict</code></li>
     *    <li><code>DatabaseMetaData.importedKeyCascade</code></li>
     *    </ul></listitem>
     * </varlistentry>
     * <varlistentry><term>11: DELETE_RULE</term>
     *   <listitem>
     *     <code>short</code> indicating what happens when the 
     *    primary key is deleted:  The values supported by QED
     *    are: <ul>
     *    <li><code>DatabaseMetaData.importedKeyRestrict</code></li>
     *    <li><code>DatabaseMetaData.importedKeyCascade</code></li>
     *    </ul></listitem>
     * </varlistentry>
     * <varlistentry><term>12: FK_NAME</term>
     *   <listitem>
     *     <code>null</code></listitem>
     * </varlistentry>
     * <varlistentry><term>13: PK_NAME</term>
     *   <listitem>
     *     <code>null</code></listitem>
     * </varlistentry>
     * <varlistentry><term>14: DEFERRABILITY</term>
     *   <listitem>
     *     <code>short</code> indicating whether 
     *    foreign key constraint
     *    checking can be deferred.  One of: <ul>
     *    <li><code>DatabaseMetaData.importedKeyInitiallyDeferred</code></li>
     *    <li><code>DatabaseMetaData.importedKeyInitiallyImmediate</code></li>
     *    <li><code>DatabaseMetaData.importedKeyNotDeferrable</code></li>
     *    </ul>
     *    <p>This QED release remembers the deferability specification
     *    in the original DDL statement, but deferred constraint checking
     *    is not supported in this release.
     * 
     * </listitem>
     * </varlistentry>
     * </variablelist>
     *
     */
    public java.sql.ResultSet getExportedKeys(String catalog, String schema,
                                              String table)
        throws SQLException
    {
        StringBuffer sb = new StringBuffer("");
        doString(sb, "PKTABLE_SCHEM", schema);
        doString(sb, "PKTABLE_NAME", table);
        Expression ex = parseExpression(sb.toString());
        MetaCrossReference mt = new MetaCrossReference(session, ex);
        return new ResultSet(mt);
    }
    
    /**
     * Returns a string consisting of all characters that can be used
     * in unquoted identifier names other than alphanumerics and _).
     * In QED, this returns the empty string, since only alphanumerics
     * and underscore are valid identifier characters.
     *
     * @return the empty string
     */
    public String getExtraNameCharacters() {
        return "";
    }
    
    /**
     * Return the string used to quote SQL identifiers.
     *
     * @return the double-quote character: <code>"</code>
     */
    public String getIdentifierQuoteString() {
        return "\"";
    }
    
    /**
     * This function returns a <code>ResultSet</code> object that 
     * contains information about the primary key columns that are
     * referenced by the foreign keys in the specified table.
     *
     * @param catalog ignored, since catalogs not supported by QED.
     * @param schema a schema name.  Used to specify the schema name
     *          of the table containing the foreign key.  <code>null</code>
     *          specifies any schema.
     * @param table the name of the table containing the foreign key.
     * @return a <code>ResultSet</code> object, with each row being a
     *          description of a foreign key column.<p>
     * @exception SQLException may be thrown.
     *
     * The columns in the <code>ResultSet</code> object have the following
     * definition:
     * <p>
     * <variablelist>
     * <varlistentry><term>1: PKTABLE_CAT</term>
     *   <listitem>
     *     <code>null</code> (Catalogs not supported by QED)</listitem>
     * </varlistentry>
     * <varlistentry><term>2: PKTABLE_SCHEM</term>
     *   <listitem>
     *      <code>String</code> giving the schema of the 
     *   primary key's table.</listitem>
     * </varlistentry>
     * <varlistentry><term>3: PKTABLE_NAME</term>
     *   <listitem>
     *     <code>String</code> giving the name of the 
     *   primary key's table</listitem>
     * </varlistentry>
     * <varlistentry><term>4: PKCOLUMN_NAME</term>
     *   <listitem>
     *     <code>String</code> giving the column name 
     *   of the primary key</listitem>
     * </varlistentry>
     * <varlistentry><term>5: FKTABLE_CAT</term>
     *   <listitem>
     *     <code>null</code> (Catalogs not supported by QED)</listitem>
     * </varlistentry>
     * <varlistentry><term>6: FKTABLE_SCHEM</term>
     *   <listitem>
     *      <code>String</code> giving the schema of 
     *   the foreign key's table.</listitem>
     * </varlistentry>
     * <varlistentry><term>7: FKTABLE_NAME</term>
     *   <listitem>
     *     <code>String</code> giving the name of the 
     *   foreign key's table</listitem>
     * </varlistentry>
     * <varlistentry><term>8: FKCOLUMN_NAME</term>
     *   <listitem>
     *     <code>String</code> giving the column name 
     *   of the foreign key</listitem>
     * </varlistentry>
     * <varlistentry><term>9: KEY_SEQ</term>
     *   <listitem>
     *     <code>short</code> indicating the column number 
     *   within the foreign key, if the foreign key has
     *   more than one column</listitem>
     * </varlistentry>
     * <varlistentry><term>10: UPDATE_RULE</term>
     *   <listitem>
     *     <code>short</code> indicating what happens when the 
     *    primary key is updated:  The values supported by QED
     *    are: <ul>
     *    <li><code>DatabaseMetaData.importedKeyRestrict</code></li>
     *    <li><code>DatabaseMetaData.importedKeyCascade</code></li>
     *    </ul></listitem>
     * </varlistentry>
     * <varlistentry><term>11: DELETE_RULE</term>
     *   <listitem>
     *     <code>short</code> indicating what happens when the 
     *    primary key is deleted:  The values supported by QED
     *    are: <ul>
     *    <li><code>DatabaseMetaData.importedKeyRestrict</code></li>
     *    <li><code>DatabaseMetaData.importedKeyCascade</code></li>
     *    </ul></listitem>
     * </varlistentry>
     * <varlistentry><term>12: FK_NAME</term>
     *   <listitem>
     *     the name of the foreign key constraint</listitem>
     * </varlistentry>
     * <varlistentry><term>13: PK_NAME</term>
     *   <listitem>
     *     <code>null</code></listitem>
     * </varlistentry>
     * <varlistentry><term>14: DEFERRABILITY</term>
     *   <listitem>
     *     <code>short</code> indicating whether 
     *    foreign key constraint
     *    checking can be deferred.  One of: <ul>
     *    <li><code>DatabaseMetaData.importedKeyInitiallyDeferred</code></li>
     *    <li><code>DatabaseMetaData.importedKeyInitiallyImmediate</code></li>
     *    <li><code>DatabaseMetaData.importedKeyNotDeferrable</code></li>
     *    </ul>
     *    <p>This QED release remembers the deferability specification
     *    in the original DDL statement, but deferred constraint checking
     *    is not supported in this release.
     * 
     * </listitem>
     * </varlistentry>
     * </variablelist>
     *
     */
    public java.sql.ResultSet getImportedKeys(String catalog, String schema,
                                              String table)
        throws SQLException
    {
        StringBuffer sb = new StringBuffer("");
        doString(sb, "FKTABLE_SCHEM", schema);
        doString(sb, "FKTABLE_NAME", table);
        Expression ex = parseExpression(sb.toString());
        MetaCrossReference mt = new MetaCrossReference(session, ex);
        return new ResultSet(mt);
    }
    
    /**
     * This function returns a <code>ResultSet</code> object that 
     * contains information about the index columns in the specified
     * table.
     *
     * @param catalog ignored, since catalogs not supported by QED.
     * @param schema a schema name.  Used to specify the schema name
     *          of the table.  <code>null</code>
     *          specifies any schema.
     * @param table the name of the table.
     * @return a <code>ResultSet</code> object, with each row being a
     *          description of an index column.<p>
     * @exception SQLException may be thrown.
     *
     * The columns in the <code>ResultSet</code> object have the following
     * definition:
     * <p>
     * <variablelist>
     * <varlistentry><term>1: TABLE_CAT</term>
     *   <listitem>
     *     <code>null</code> (Catalogs not supported by QED)</listitem>
     * </varlistentry>
     * <varlistentry><term>2: TABLE_SCHEM</term>
     *   <listitem>
     *      <code>String</code> giving the table's schema</listitem>
     * </varlistentry>
     * <varlistentry><term>3: TABLE_NAME</term>
     *   <listitem>
     *     <code>String</code> giving the table's name</listitem>
     * </varlistentry>
     * <varlistentry><term>4: NON_UNIQUE</term>
     *   <listitem>
     *     <code>boolean</code> <code>false</code> if index values 
     *   must be unique, <code>true</code> otherwise.</listitem>
     * </varlistentry>
     * <varlistentry><term>5: INDEX_QUALIFIER</term>
     *   <listitem>
     *     QED returns <code>"global"</code> if this is a global
     *     index, <code>null</code> otherwise.</listitem>
     * </varlistentry>
     * <varlistentry><term>6: INDEX_NAME</term>
     *   <listitem>
     *     <code>String</code> the name of the index</listitem>
     * </varlistentry>
     * <varlistentry><term>7: TYPE</term>
     *   <listitem>
     *     <code>short</code> <code>DatabaseMetaData.tableIndexOther</code></listitem>
     * </varlistentry>
     * <varlistentry><term>8: ORDINAL_POSITION</term>
     *   <listitem>
     *     <code>short</code> indicating the column sequence
     *   within the index</listitem>
     * </varlistentry>
     * <varlistentry><term>9: COLUMN_NAME</term>
     *   <listitem>
     *     <code>String</code> The name of the column</listitem>
     * </varlistentry>
     * <varlistentry><term>10: ASC_OR_DESC</term>
     *   <listitem>
     *     <code>String</code> always <code>"A"</code></listitem>
     * </varlistentry>
     * <varlistentry><term>11: CARDINALITY</term>
     *   <listitem>
     *     <code>null</code> The JDBC specification says that 
     *    this returns the number of unique values in the index,
     *    a statistic which is not kept in this release of
     *    QED.</listitem>
     * </varlistentry>
     * <varlistentry><term>12: PAGES</term>
     *   <listitem>
     *     <code>null</code> The JDBC specification says that 
     *    this returns the number of pages used by the index,
     *    a statistic which is not kept in this release of
     *    QED.</listitem>
     * </varlistentry>
     * <varlistentry><term>13: FILTER_CONDITION</term>
     *   <listitem>
     *     <code>null</code> not supported by QED
     * </listitem>
     * </varlistentry>
     * </variablelist>
     */
    public java.sql.ResultSet getIndexInfo(String catalog, String schema,
                                           String table, boolean unique,
                                           boolean approximate)
        throws SQLException
    {
        StringBuffer sb = new StringBuffer("");
        doString(sb, "TABLE_SCHEM", schema);
        doString(sb, "TABLE_NAME", table);
        if (unique) {
            if (sb.length() > 0) sb.append(" and ");
            sb.append("not NON_UNIQUE");
        }
        Expression ex = parseExpression(sb.toString());
        MetaIndexInfo mi = new MetaIndexInfo(session, ex);
        return new ResultSet(mi);
    }

    /**
     * Return the maximum size of a binary literal.  QED has no
     * architectural limitation on literal sizes, and so always
     * returns zero.
     *
     * @return zero, meaning unlimited.
     */
    public int getMaxBinaryLiteralLength() {
        return 0;
    }
    
    /**
     * QED doesn't support catalogs, but if it did, it wouldn't impose
     * a limit on the length of their names.
     *
     * @return zero, meaning unlimited.
     */
    public int getMaxCatalogNameLength() {
        return 0;
    }
    
    /**
     * Return the maximum size of a character literal.  QED has no
     * architectural limitation on literal sizes, and so always
     * returns zero.
     *
     * @return zero, meaning unlimited.
     */
    public int getMaxCharLiteralLength() {
        return 0;
    }
    
    /**
     * Return the maximum length of a column name.  QED has no
     * architectural limitation on name sizes, and so always
     * returns zero.
     *
     * @return zero, meaning unlimited.
     */
    public int getMaxColumnNameLength() {
        return 0;
    }
    
    /**
     * Return the maximum number of columns in a <code>GROUP BY</code>
     * clause.  QED has no architectural limitation on 
     * <code>GROUP BY</code> clauses, and so always
     * returns zero.
     *
     * @return zero, meaning unlimited.
     */
    public int getMaxColumnsInGroupBy() {
        return 0;
    }
    
    /**
     * Return the maximum number of columns in an index.
     * QED has no architectural limitation on index columns,
     * and so always returns zero.
     *
     * @return zero, meaning unlimited.
     */
    public int getMaxColumnsInIndex() { 
        return 0;
    }
    
    /**
     * Return the maximum number of columns in an <code>ORDER BY</code>
     * clause.  QED has no architectural limitation on 
     * <code>ORDER BY</code> clauses, and so always
     * returns zero.
     *
     * @return zero, meaning unlimited.
     */
    public int getMaxColumnsInOrderBy() {
        return 0;
    }
    
    /**
     * Return the maximum number of columns in a <code>SELECT</code>
     * clause.  QED has no architectural limitation on 
     * <code>SELECT</code> clauses, and so always
     * returns zero.
     *
     * @return zero, meaning unlimited.
     */
    public int getMaxColumnsInSelect() {
        return 0;
    }
    
    /**
     * Return the maximum number of columns in an table.
     * QED has no architectural limitation on table columns,
     * and so always returns zero.
     *
     * @return zero, meaning unlimited.
     */
    public int getMaxColumnsInTable() {
        return 0;
    }
    
    /**
     * Return the maximum number of active connections that can
     * be maintained by this driver instance.
     * QED has no architectural limitation on datbase connections,
     * and so always returns zero.
     *
     * @return zero, meaning unlimited.
     */
    public int getMaxConnections() {
        return 0;
    }
    
    /**
     * QED doesn't support named cursors, but if it did, it wouldn't impose
     * a limit on the length of their names.
     *
     * @return zero, meaning unlimited.
     */
    public int getMaxCursorNameLength() {
        return 0;
    }
    
    /**
     * Return the maximum number of bytes in an index.  QED has no
     * architectural limitation on index sizes, and so always returns zero.
     *
     * @return zero, meaning unlimited.
     */
    public int getMaxIndexLength() {
        return 0;
    }
    
    /**
     * QED doesn't support stored procedures, but if it did, it wouldn't impose
     * a limit on the length of their names.
     *
     * @return zero, meaning unlimited.
     */
    public int getMaxProcedureNameLength() {
        return 0;
    }
    
    /**
     * Return the maximum number of bytes in a single row.  QED has no
     * architectural limitation on row sizes, and so always returns zero.
     *
     * @return zero, meaning unlimited.
     */
    public int getMaxRowSize() {
        return 0;
    }
    
    /**
     * Return the maximum length of a schema name.  QED has no
     * architectural limitation on schema sizes, and so always
     * returns zero.
     *
     * @return zero, meaning unlimited.
     */
    public int getMaxSchemaNameLength() {
        return 0;
    }
    
    /**
     * Return the maximum number of characters in an SQL statement. QED has no
     * architectural limitation on statement sizes, and so always
     * returns zero.
     *
     * @return zero, meaning unlimited.
     */
    public int getMaxStatementLength() {
        return 0;
    }
    
    /**
     * Return the maximum number of concurrently active statements that
     * can be open on a single connection.  The QED threading model
     * essentially restricts the application to a single active 
     * <code>ResultSet</code> per connection.  If another statement
     * is executed which creates a <code>ResultSet</code>, the first
     * <code>ResultSet</code> will be automatically closed.
     *
     * @return one
     */
    public int getMaxStatements() {
        return 1;
    }
    
    /**
     * Return the maximum length of a table name.  QED has no
     * architectural limitation on name lengths, and so always
     * returns zero.
     *
     * @return zero, meaning unlimited.
     */
    public int getMaxTableNameLength() {
        return 0;
    }
    
    /**
     * Return the maximum number of tables allowed in a <code>SELECT</code>
     * clause. QED has no
     * architectural limitation on this, and so always
     * returns zero.
     *
     * @return zero, meaning unlimited.
     */
    public int getMaxTablesInSelect() {
        return 0;
    }
    
    /**
     * Return the maximum length of a user name.  QED has no
     * architectural limitation on name lengths, and so always
     * returns zero.
     *
     * @return zero, meaning unlimited.
     */
    public int getMaxUserNameLength() {
        return 0;
    }
    
    /**
     * Return a comma-separated string containing the names of the 
     * numeric functions supported by QED.
     * This string contains the Open Group
     * CLI names for the following functions:
     *
     * <p><code>
     * ABS,ACOS,ASIN,ATAN,ATAN2,CEILING,COS,COT,DEGREES,EXP,FLOOR
     * LOG,LOG10,MOD,PI,POWER,RADIANS,RAND,ROUND,SIGN,SIN,SQRT,TAN
     * TRUNCATE
     * </code></p>
     */
    public String getNumericFunctions() {
        return 
            "ABS,ACOS,ASIN,ATAN,ATAN2,CEILING,COS,COT,DEGREES,EXP,FLOOR," +
            "LOG,LOG10,MOD,PI,POWER,RADIANS,RAND,ROUND,SIGN,SIN,SQRT,TAN," +
            "TRUNCATE";
    }
    
    /**
     * This function returns a <code>ResultSet</code> describing the 
     * primary key columns of the specified table.
     *
     * @param catalog ignored, since catalogs not supported by QED.
     * @param schema a schema name.  Used to specify the schema name
     *          of the table.  <code>null</code>
     *          specifies any schema.
     * @param table the name of the table.
     * @return a <code>ResultSet</code> object, with each row being a
     *          description of an index column.<p>
     * @exception SQLException may be thrown.
     *
     * The columns in the <code>ResultSet</code> object have the following
     * definition:
     * <p>
     * <variablelist>
     * <varlistentry><term>1: TABLE_CAT</term>
     *   <listitem>
     *     <code>null</code> (Catalogs not supported by QED)</listitem>
     * </varlistentry>
     * <varlistentry><term>2: TABLE_SCHEM</term>
     *   <listitem>
     *      <code>String</code> giving the table's schema</listitem>
     * </varlistentry>
     * <varlistentry><term>3: TABLE_NAME</term>
     *   <listitem>
     *     <code>String</code> giving the table's name</listitem>
     * </varlistentry>
     * <varlistentry><term>4: COLUMN_NAME</term>
     *   <listitem>
     *     <code>String</code> giving the column name</listitem>
     * </varlistentry>
     * <varlistentry><term>5: KEY_SEQ</term>
     *   <listitem>
     *     <code>short</code> indicating the column sequence
     *   within the primary key</listitem>
     * </varlistentry>
     * <varlistentry><term>6: PK_NAME</term>
     *   <listitem>
     *     <code>String</code> The name of the primary key constraint</listitem>
     * </varlistentry>
     * </variablelist>
     */
    public java.sql.ResultSet getPrimaryKeys(String catalog, String schema,
                                             String table)
        throws SQLException
    {
        StringBuffer sb = new StringBuffer("");
        doString(sb, "TABLE_SCHEM", schema);
        doString(sb, "TABLE_NAME", table);
        Expression ex = parseExpression(sb.toString());
        MetaPrimaryKeys mt = new MetaPrimaryKeys(session, ex);
        return new ResultSet(mt);
    }

    /**
     * Stored procedures aren't supported by QED, but
     * we return an empty result set with the right signature as a courtesy.
     *
     * @param catalog N/A
     * @param schemaNamePattern N/A
     * @param procedureNamePattern N/A
     * @param columnNamePattern N/A
     */
    public java.sql.ResultSet getProcedureColumns(String catalog,
                                                  String schemaNamePattern,
                                                  String procedureNamePattern,
                                                  String columnNamePattern)
        throws SQLException
    {
        return new ResultSet(MetaCursor.find(session,
                                             "SYSTEM.PROCEDURECOLUMNS"));
    }
    /**
     * Stored procedures aren't supported by QED, but
     * we return an empty result set with the right signature as a courtesy.
     *
     * @param catalog N/A
     * @param schemaNamePattern N/A
     * @param procedureNamePattern N/A
     */
    public java.sql.ResultSet getProcedures(String catalog,
                                            String schemaNamePattern,
                                            String procedureNamePattern)
        throws SQLException
    {
        return new ResultSet(MetaCursor.find(session, "SYSTEM.PROCEDURES"));
    }
    
    
    /**
     * Whatever.
     */
    public String getProcedureTerm()
        throws SQLException
    {
        return "proc";
    }

    /**
     * Return a result set containing the names of the database schemas.
     *
     */
    public java.sql.ResultSet getSchemas()
        throws SQLException
    {
        return new ResultSet(MetaCursor.find(session, "SYSTEM.SCHEMAS"));
    }

    /**
     * Get the "database vendor's preferred term for 'schema'".
     *
     * @return "schema"
     */
    public String getSchemaTerm() {
        return "schema";
    }

    /**
     * Return the default value for the escape sequence that can be
     * used to escape literal "_" and "%" pattern characters in
     * <code>LIKE</code> pattern strings.
     *
     * @return the string "\"
     */
    public String getSearchStringEscape() {
        return ValuePattern.defaultEscape;
    }
    
    /**
     * Returns a list of database keywords that are not also SQL-92
     * keywords.  For this release of QED, this is currently the
     * empty string.
     *
     * @return ""
     */
    public String getSQLKeywords() {
        return "";
    }
    
    /**
     * Return a comma-separated string containing the names of the 
     * string functions supported by QED.
     * This string contains the Open Group
     * CLI names for the following functions:
     *
     * <p><code>
     * ASCII, CHAR, CONCAT, DIFFERENCE, INSERT, LCASE, LOWER, LEFT, LENGTH
     * LOCATE, LTRIM, REPEAT, REPLACE, RIGHT, RTRIM, SOUNDEX, SPACE
     * SUBSTRING, UCASE, UPPER
     * </code</p>
     */
    public String getStringFunctions() {
        return 
            "ASCII,CHAR,CONCAT,DIFFERENCE,INSERT,LCASE,LOWER,LEFT,LENGTH," +
            "LOCATE,LTRIM,REPEAT,REPLACE,RIGHT,RTRIM,SOUNDEX,SPACE," +
            "SUBSTRING,UCASE,UPPER";
    }
    
    /**
     * Return a comma-separated string containing the names of the 
     * system functions supported by QED.
     * This string contains the Open Group
     * CLI names for the following functions:
     *
     * <p><code>DATABASE, IFNULL, USER</code></p>
     */
    public String getSystemFunctions() {
        return "DATABASE,IFULL,USER";
    }
    
    /**
     * QED doesn't support column privs, but we return an empty ResultSet
     * of the right signature as a courtesy.
     */
    public java.sql.ResultSet getTablePrivileges(String catalog, String schema,
                                                 String tableNamePattern)
        throws SQLException
    {
        return new ResultSet(MetaCursor.find(session,
                                             "SYSTEM.TABLEPRIVILEGES"));
    }
    
    /**
     * This function returns a <code>ResultSet<code> describing the 
     * tables in the database.
     *
     * @param catalog ignored, since catalogs not supported by QED.
     * @param schemaPattern a SQL "like" pattern.  All schema names matching
     *          this pattern are selected.  If this parameter is the empty
     *          string, all schemas are selected.
     * @param tableNamePattern a SQL "like" pattern.  All table names 
     *          matching this pattern are selected.
     * @param types an array of strings specifying the table types to
     *          be returned, from the set: <code>"TABLE", "VIEW",
     *          "LOCAL TEMPORARY", "GLOBAL TEMPORARY"</code>
     * @return a <code>ResultSet</code> object, with each row being a
     *          description of a table.<p>
     * @exception SQLException may be thrown.
     *
     * The columns in the <code>ResultSet</code> object have the following
     * definition:
     * <p>
     * <variablelist>
     * <varlistentry><term>1: TABLE_CAT</term>
     *   <listitem>
     *     <code>null</code> (Catalogs not supported by QED)</listitem>
     * </varlistentry>
     * <varlistentry><term>2: TABLE_SCHEM</term>
     *   <listitem>
     *      <code>String</code> giving the table's schema</listitem>
     * </varlistentry>
     * <varlistentry><term>3: TABLE_NAME</term>
     *   <listitem>
     *     <code>String</code> giving the table's name</listitem>
     * </varlistentry>
     * <varlistentry><term>4: TABLE_TYPE</term>
     *   <listitem>
     *     <code>String</code> The table type.  One of: <ul>
     *   <li><code>TABLE</code></li>
     *   <li><code>VIEW</code></li>
     *   <li><code>GLOBAL TEMPORARY</code></li>
     *   <li><code>LOCAL TEMPORARY</code></li>
     *   </ul></listitem>
     * </varlistentry>
     * <varlistentry><term>5: REMARKS</term>
     *   <listitem>
     *     <code>null</code></listitem>
     * </varlistentry>
     * </variablelist>
     */
    public java.sql.ResultSet getTables(String catalog, String schemaPattern,
                                        String tableNamePattern, 
                                        String[] types)
        throws SQLException
    {
        StringBuffer sb = new StringBuffer();
        doPattern(sb, "TABLE_SCHEM", schemaPattern);
        doPattern(sb, "TABLE_NAME", tableNamePattern);
        if (types != null) {
            if (sb.length() > 0) sb.append(" AND ");
            sb.append("TABLE_TYPE in (");
            for (int i = 0; i < types.length; i++) {
                if (i > 0) sb.append(',');
                sb.append('\'');
                sb.append(types[i].toUpperCase());
                sb.append('\'');
            }
            sb.append(")");
        }
        Expression ex = parseExpression(sb.toString());
        MetaTables mt = new MetaTables(session, ex);
        return new ResultSet(mt);
    }

    /**
     * This function returns a <code>ResultSet</code> which describes
     * the table types supported by QED.
     *
     * @exception SQLException may be thrown.
     *
     * The column in the <code>ResultSet</code> object has the following
     * definition:
     * <p>
     * <variablelist>
     * <varlistentry><term>1: TABLE_TYPE</term>
     *   <listitem>
     *     <code>String</code> listing the table type.
     *   One of: <ul>
     *   <li><code>TABLE</code></li>
     *   <li><code>VIEW</code></li>
     *   <li><code>GLOBAL TEMPORARY</code></li>
     *   <li><code>LOCAL TEMPORARY</code></li>
     *   </ul></listitem>
     * </varlistentry>
     * </variablelist>
     */
    public java.sql.ResultSet getTableTypes()
        throws SQLException
    {
        MetaTableTypes mt = new MetaTableTypes(session);
        return new ResultSet(mt);
    }
    
    Expression parseExpression(String s) throws SQLException {
        if (s.length() == 0) return null;
        try {
            session.makeTransaction();
            SQLParser p = new SQLParser(session, s, false);
            return p.expression();
        } catch (antlr.TokenStreamException e) {
            throw new SQLException(e.toString(), "Q000Y");
        } catch (antlr.RecognitionException e) {
            throw new SQL