Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
  
  
  package org.apache.hive.jdbc;
  
  import java.util.Arrays;
  
HiveDatabaseMetaData.
  
  public class HiveDatabaseMetaData implements DatabaseMetaData {
  
    private final HiveConnection connection;
    private final TCLIService.Iface client;
    private final TSessionHandle sessHandle;
    private static final String CATALOG_SEPARATOR = ".";
  
    private static final char SEARCH_STRING_ESCAPE = '\\';
  
    //  The maximum column length = MFieldSchema.FNAME in metastore/src/model/package.jdo
    private static final int maxColumnNameLength = 128;
  
    //  Cached values, to save on round trips to database.
    private String dbVersion = null;

  
  
    public HiveDatabaseMetaData(HiveConnection connectionTCLIService.Iface client,
        TSessionHandle sessHandle) {
      this. = connection;
      this. = client;
      this. = sessHandle;
    }
  
    public boolean allProceduresAreCallable() throws SQLException {
      throw new SQLException("Method not supported");
    }
  
    public boolean allTablesAreSelectable() throws SQLException {
      return true;
    }
  
    public boolean autoCommitFailureClosesAllResultSets() throws SQLException {
      throw new SQLException("Method not supported");
    }
  
    public boolean dataDefinitionCausesTransactionCommit() throws SQLException {
      throw new SQLException("Method not supported");
    }
  
    public boolean dataDefinitionIgnoredInTransactions() throws SQLException {
      throw new SQLException("Method not supported");
   }
 
   public boolean deletesAreDetected(int typethrows SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean doesMaxRowSizeIncludeBlobs() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public ResultSet getAttributes(String catalogString schemaPattern,
       String typeNamePatternString attributeNamePatternthrows SQLException {
     throw new SQLException("Method not supported");
   }
 
   public ResultSet getBestRowIdentifier(String catalogString schema,
       String tableint scopeboolean nullablethrows SQLException {
     throw new SQLException("Method not supported");
   }
 
   public String getCatalogSeparator() throws SQLException {
     return ;
   }
 
   public String getCatalogTerm() throws SQLException {
     return "instance";
   }
 
   public ResultSet getCatalogs() throws SQLException {
     TGetCatalogsResp catalogResp;
 
     try {
       catalogResp = .GetCatalogs(new TGetCatalogsReq());
     } catch (TException e) {
       throw new SQLException(e.getMessage(), "08S01"e);
     }
     Utils.verifySuccess(catalogResp.getStatus());
 
     return new HiveQueryResultSet.Builder()
     .setClient()
     .setStmtHandle(catalogResp.getOperationHandle())
     .build();
   }
 
     throw new SQLException("Method not supported");
   }
 
   public ResultSet getColumnPrivileges(String catalogString schema,
       String tableString columnNamePatternthrows SQLException {
     throw new SQLException("Method not supported");
   }
 
   public ResultSet getPseudoColumns(String catalogString schemaPattern,
       String tableNamePatternString columnNamePatternthrows SQLException {
     // JDK 1.7
     throw new SQLException("Method not supported");
   }
 
   public boolean generatedKeyAlwaysReturned() throws SQLException {
     // JDK 1.7
     throw new SQLException("Method not supported");
   }

  
Convert a pattern containing JDBC catalog search wildcards into Java regex patterns.

Parameters:
pattern input which may contain '%' or '_' wildcard characters, or these characters escaped using getSearchStringEscape().
Returns:
replace %/_ with regex search characters, also handle escaped characters.
 
   private String convertPattern(final String pattern) {
     if (pattern==null) {
       return ".*";
     } else {
       StringBuilder result = new StringBuilder(pattern.length());
 
       boolean escaped = false;
       for (int i = 0, len = pattern.length(); i < leni++) {
         char c = pattern.charAt(i);
         if (escaped) {
           if (c != ) {
             escaped = false;
           }
           result.append(c);
         } else {
           if (c == ) {
             escaped = true;
             continue;
           } else if (c == '%') {
             result.append(".*");
           } else if (c == '_') {
             result.append('.');
           } else {
             result.append(Character.toLowerCase(c));
           }
         }
       }
 
       return result.toString();
     }
   }
 
   public ResultSet getColumns(String catalogString schemaPattern,
       String tableNamePatternString columnNamePatternthrows SQLException {
     TGetColumnsResp colResp;
     TGetColumnsReq colReq = new TGetColumnsReq();
     colReq.setSessionHandle();
     colReq.setCatalogName(catalog);
     colReq.setSchemaName(schemaPattern);
     colReq.setTableName(tableNamePattern);
     colReq.setColumnName(columnNamePattern);
     try {
       colResp = .GetColumns(colReq);
     } catch (TException e) {
       throw new SQLException(e.getMessage(), "08S01"e);
     }
     Utils.verifySuccess(colResp.getStatus());
     // build the resultset from response
     return new HiveQueryResultSet.Builder()
     .setClient()
     .setStmtHandle(colResp.getOperationHandle())
     .build();
   }

  
We sort the output of getColumns to guarantee jdbc compliance. First check by table name then by ordinal position
 
   private class GetColumnsComparator implements Comparator<JdbcColumn> {
 
     public int compare(JdbcColumn o1JdbcColumn o2) {
       int compareName = o1.getTableName().compareTo(o2.getTableName());
       if (compareName==0) {
         if (o1.getOrdinalPos() > o2.getOrdinalPos()) {
           return 1;
         } else if (o1.getOrdinalPos() < o2.getOrdinalPos()) {
           return -1;
         }
         return 0;
       } else {
         return compareName;
       }
     }
   }
 
   public Connection getConnection() throws SQLException {
     return this.;
   }
 
   public ResultSet getCrossReference(String primaryCatalog,
       String primarySchemaString primaryTableString foreignCatalog,
       String foreignSchemaString foreignTablethrows SQLException {
     throw new SQLException("Method not supported");
   }
 
   public int getDatabaseMajorVersion() throws SQLException {
     return Utils.getVersionPart(getDatabaseProductVersion(), 0);
   }
 
   public int getDatabaseMinorVersion() throws SQLException {
     return Utils.getVersionPart(getDatabaseProductVersion(), 1);
   }
 
   public String getDatabaseProductName() throws SQLException {
     return resp.getInfoValue().getStringValue();
   }
 
   public String getDatabaseProductVersion() throws SQLException {
     if ( != null) { //lazy-caching of the version.
       return ;
     }
 
     this. = resp.getInfoValue().getStringValue();
     return ;
   }
 
   public int getDefaultTransactionIsolation() throws SQLException {
     return .;
   }
 
   public int getDriverMajorVersion() {
     return HiveDriver.getMajorDriverVersion();
   }
 
   public int getDriverMinorVersion() {
     return HiveDriver.getMinorDriverVersion();
   }
 
   public String getDriverName() throws SQLException {
   }
 
   public String getDriverVersion() throws SQLException {
   }
 
   public ResultSet getExportedKeys(String catalogString schemaString table)
       throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public String getExtraNameCharacters() throws SQLException {
     // TODO: verify that this is correct
     return "";
   }
 
   public ResultSet getFunctionColumns(String arg0String arg1String arg2,
       String arg3throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public ResultSet getFunctions(String catalogNameString schemaPatternString functionNamePattern)
       throws SQLException {
     TGetFunctionsResp funcResp;
     TGetFunctionsReq getFunctionsReq = new TGetFunctionsReq();
     getFunctionsReq.setSessionHandle();
     getFunctionsReq.setCatalogName(catalogName);
     getFunctionsReq.setSchemaName(schemaPattern);
     getFunctionsReq.setFunctionName(functionNamePattern);
 
     try {
       funcResp = .GetFunctions(getFunctionsReq);
     } catch (TException e) {
       throw new SQLException(e.getMessage(), "08S01"e);
     }
     Utils.verifySuccess(funcResp.getStatus());
 
     return new HiveQueryResultSet.Builder()
     .setClient()
     .setStmtHandle(funcResp.getOperationHandle())
     .build();
   }
 
   public String getIdentifierQuoteString() throws SQLException {
     return " ";
   }
 
   public ResultSet getImportedKeys(String catalogString schemaString table)
       throws SQLException {
     return new HiveQueryResultSet.Builder()
     .setClient()
     .setEmptyResultSet(true)
     .setSchema(
         Arrays.asList(
             "PKTABLE_CAT",
             "PKTABLE_SCHEM",
             "PKTABLE_NAME",
             "PKCOLUMN_NAME",
             "FKTABLE_CAT",
             "FKTABLE_SCHEM",
             "FKTABLE_NAME",
             "FKCOLUMN_NAME",
             "KEY_SEQ",
             "UPDATE_RULE",
             "DELETE_RULE",
             "FK_NAME",
             "PK_NAME",
             "DEFERRABILITY"),
         Arrays.asList(
             "STRING",
             "STRING",
             "STRING",
             "STRING",
             "STRING",
             "STRING",
             "STRING",
             "STRING",
             "SMALLINT",
             "SMALLINT",
             "SMALLINT",
             "STRING",
             "STRING",
             "STRING"))
             .build();
   }
 
   public ResultSet getIndexInfo(String catalogString schemaString table,
       boolean uniqueboolean approximatethrows SQLException {
     return new HiveQueryResultSet.Builder()
         .setClient()
         .setEmptyResultSet(true)
         .setSchema(
             Arrays.asList("TABLE_CAT""TABLE_SCHEM""TABLE_NAME""NON_UNIQUE",
                 "INDEX_QUALIFIER""INDEX_NAME""TYPE""ORDINAL_POSITION""COLUMN_NAME",
                 "ASC_OR_DESC""CARDINALITY""PAGES""FILTER_CONDITION"),
             Arrays.asList("STRING""STRING""STRING""BOOLEAN""STRING""STRING""SHORT",
                 "SHORT""STRING""STRING""INT""INT""STRING")).build();
   }
 
   public int getJDBCMajorVersion() throws SQLException {
     return 3;
   }
 
   public int getJDBCMinorVersion() throws SQLException {
     return 0;
   }
 
   public int getMaxBinaryLiteralLength() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public int getMaxCatalogNameLength() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public int getMaxCharLiteralLength() throws SQLException {
     throw new SQLException("Method not supported");
   }

  
Returns the value of maxColumnNameLength.
 
   public int getMaxColumnNameLength() throws SQLException {
     return ;
   }
 
   public int getMaxColumnsInGroupBy() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public int getMaxColumnsInIndex() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public int getMaxColumnsInOrderBy() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public int getMaxColumnsInSelect() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public int getMaxColumnsInTable() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public int getMaxConnections() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public int getMaxCursorNameLength() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public int getMaxIndexLength() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public int getMaxProcedureNameLength() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public int getMaxRowSize() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public int getMaxSchemaNameLength() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public int getMaxStatementLength() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public int getMaxStatements() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public int getMaxTableNameLength() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public int getMaxTablesInSelect() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public int getMaxUserNameLength() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public String getNumericFunctions() throws SQLException {
     return "";
   }
 
   public ResultSet getPrimaryKeys(String catalogString schemaString table)
       throws SQLException {
     // Hive doesn't support primary keys
     // using local schema with empty resultset
         setSchema(Arrays.asList("TABLE_CAT""TABLE_SCHEM""TABLE_NAME""COLUMN_NAME""KEY_SEQ""PK_NAME" ),
             Arrays.asList("STRING",    "STRING",      "STRING",     "STRING",       "INT",  "STRING"))
             .build();
   }
 
   public ResultSet getProcedureColumns(String catalogString schemaPattern,
       String procedureNamePatternString columnNamePattern)
       throws SQLException {
     // Hive doesn't support primary keys
     // using local schema with empty resultset
                   setSchema(
                     Arrays.asList("PROCEDURE_CAT""PROCEDURE_SCHEM""PROCEDURE_NAME""COLUMN_NAME""COLUMN_TYPE",
                               "DATA_TYPE""TYPE_NAME""PRECISION""LENGTH""SCALE""RADIX""NULLABLE""REMARKS",
                               "COLUMN_DEF""SQL_DATA_TYPE""SQL_DATETIME_SUB""CHAR_OCTET_LENGTH""ORDINAL_POSITION",
                               "IS_NULLABLE""SPECIFIC_NAME"),
                     Arrays.asList("STRING""STRING""STRING""STRING""SMALLINT""INT",
                               "STRING""INT""INT""SMALLINT""SMALLINT""SMALLINT""STRING""STRING",
                               "INT""INT""INT""INT",
                               "STRING""STRING"))
                   .build();
   }
 
   public String getProcedureTerm() throws SQLException {
     return new String("UDF");
   }
 
   public ResultSet getProcedures(String catalogString schemaPattern,
       String procedureNamePatternthrows SQLException {
     // Hive doesn't support primary keys
     // using local schema with empty resultset
                   setSchema(
                     Arrays.asList("PROCEDURE_CAT""PROCEDURE_SCHEM""PROCEDURE_NAME""RESERVERD""RESERVERD",
                                   "RESERVERD""REMARKS""PROCEDURE_TYPE""SPECIFIC_NAME"),
                     Arrays.asList("STRING""STRING""STRING""STRING""STRING",
                                   "STRING""STRING""SMALLINT""STRING"))
                   .build();
   }
 
   public int getResultSetHoldability() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public RowIdLifetime getRowIdLifetime() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public String getSQLKeywords() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public int getSQLStateType() throws SQLException {
   }
 
   public String getSchemaTerm() throws SQLException {
     return "database";
   }
 
   public ResultSet getSchemas() throws SQLException {
     return getSchemas(nullnull);
   }
 
   public ResultSet getSchemas(String catalogString schemaPattern)
       throws SQLException {
     TGetSchemasResp schemaResp;
 
     TGetSchemasReq schemaReq = new TGetSchemasReq();
     schemaReq.setSessionHandle();
     if (catalog != null) {
       schemaReq.setCatalogName(catalog);
     }
     if (schemaPattern == null) {
       schemaPattern = "%";
     }
     schemaReq.setSchemaName(schemaPattern);
 
     try {
       schemaResp = .GetSchemas(schemaReq);
     } catch (TException e) {
       throw new SQLException(e.getMessage(), "08S01"e);
     }
     Utils.verifySuccess(schemaResp.getStatus());
 
     return new HiveQueryResultSet.Builder()
     .setClient()
     .setStmtHandle(schemaResp.getOperationHandle())
     .build();
   }
 
   public String getSearchStringEscape() throws SQLException {
     return String.valueOf();
   }
 
   public String getStringFunctions() throws SQLException {
     return "";
   }
 
   public ResultSet getSuperTables(String catalogString schemaPattern,
       String tableNamePatternthrows SQLException {
     throw new SQLException("Method not supported");
   }
 
   public ResultSet getSuperTypes(String catalogString schemaPattern,
       String typeNamePatternthrows SQLException {
     throw new SQLException("Method not supported");
   }
 
   public String getSystemFunctions() throws SQLException {
     return "";
   }
 
   public ResultSet getTablePrivileges(String catalogString schemaPattern,
       String tableNamePatternthrows SQLException {
     throw new SQLException("Method not supported");
   }
 
   public ResultSet getTableTypes() throws SQLException {
     TGetTableTypesResp tableTypeResp;
 
     try {
       tableTypeResp = .GetTableTypes(new TGetTableTypesReq());
     } catch (TException e) {
       throw new SQLException(e.getMessage(), "08S01"e);
     }
     Utils.verifySuccess(tableTypeResp.getStatus());
 
     return new HiveQueryResultSet.Builder()
     .setClient()
     .setStmtHandle(tableTypeResp.getOperationHandle())
     .build();
   }
 
   public ResultSet getTables(String catalogString schemaPattern,
                              String tableNamePatternString[] typesthrows SQLException {
     TGetTablesResp getTableResp;
     if (schemaPattern == null) {
       // if schemaPattern is null it means that the schemaPattern value should not be used to narrow the search
       schemaPattern = "%";
     }
     TGetTablesReq getTableReq = new TGetTablesReq();
     getTableReq.setTableName(tableNamePattern);
 
     // TODO: need to set catalog parameter
 
     if (types != null) {
       getTableReq.setTableTypes(Arrays.asList(types));
     }
     if (schemaPattern != null) {
       getTableReq.setSchemaName(schemaPattern);
     }
 
     try {
       getTableResp = .GetTables(getTableReq);
     } catch (TException e) {
       throw new SQLException(e.getMessage(), "08S01"e);
     }
     Utils.verifySuccess(getTableResp.getStatus());
 
     return new HiveQueryResultSet.Builder()
     .setClient()
     .setStmtHandle(getTableResp.getOperationHandle())
     .build();
   }

  
We sort the output of getTables to guarantee jdbc compliance. First check by table type then by table name
 
   private class GetTablesComparator implements Comparator<JdbcTable> {
 
     public int compare(JdbcTable o1JdbcTable o2) {
       int compareType = o1.getType().compareTo(o2.getType());
       if (compareType==0) {
         return o1.getTableName().compareTo(o2.getTableName());
       } else {
         return compareType;
       }
     }
   }

  
Translate hive table types into jdbc table types.

Parameters:
hivetabletype
Returns:
the type of the table
 
   public static String toJdbcTableType(String hivetabletype) {
     if (hivetabletype==null) {
       return null;
     } else if (hivetabletype.equals(..toString())) {
       return "TABLE";
     } else if (hivetabletype.equals(..toString())) {
       return "VIEW";
     } else if (hivetabletype.equals(..toString())) {
       return "EXTERNAL TABLE";
     } else {
       return hivetabletype;
     }
   }
 
   public String getTimeDateFunctions() throws SQLException {
     return "";
   }
 
   public ResultSet getTypeInfo() throws SQLException {
     TGetTypeInfoResp getTypeInfoResp;
     TGetTypeInfoReq getTypeInfoReq = new TGetTypeInfoReq();
     getTypeInfoReq.setSessionHandle();
     try {
       getTypeInfoResp = .GetTypeInfo(getTypeInfoReq);
     } catch (TException e) {
       throw new SQLException(e.getMessage(), "08S01"e);
     }
     Utils.verifySuccess(getTypeInfoResp.getStatus());
     return new HiveQueryResultSet.Builder()
     .setClient()
     .setStmtHandle(getTypeInfoResp.getOperationHandle())
     .build();
   }
 
   public ResultSet getUDTs(String catalogString schemaPattern,
       String typeNamePatternint[] typesthrows SQLException {
 
     return new HiveMetaDataResultSet(
             Arrays.asList("TYPE_CAT""TYPE_SCHEM""TYPE_NAME""CLASS_NAME""DATA_TYPE"
                     , "REMARKS""BASE_TYPE")
             , Arrays.asList("STRING""STRING""STRING""STRING""INT""STRING""INT")
             , null) {
 
       public boolean next() throws SQLException {
         return false;
       }
 
       public <T> T getObject(String columnLabelClass<T> typethrows SQLException {
         // JDK 1.7
         throw new SQLException("Method not supported");
       }
 
       public <T> T getObject(int columnIndexClass<T> typethrows SQLException {
         // JDK 1.7
         throw new SQLException("Method not supported");
         }
     };
   }
 
   public String getURL() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public String getUserName() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public ResultSet getVersionColumns(String catalogString schemaString table)
       throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean insertsAreDetected(int typethrows SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean isCatalogAtStart() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean isReadOnly() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean locatorsUpdateCopy() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean nullPlusNonNullIsNull() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean nullsAreSortedAtEnd() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean nullsAreSortedAtStart() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean nullsAreSortedHigh() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean nullsAreSortedLow() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean othersDeletesAreVisible(int typethrows SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean othersInsertsAreVisible(int typethrows SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean othersUpdatesAreVisible(int typethrows SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean ownDeletesAreVisible(int typethrows SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean ownInsertsAreVisible(int typethrows SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean ownUpdatesAreVisible(int typethrows SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean storesLowerCaseIdentifiers() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean storesLowerCaseQuotedIdentifiers() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean storesMixedCaseIdentifiers() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean storesMixedCaseQuotedIdentifiers() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean storesUpperCaseIdentifiers() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean storesUpperCaseQuotedIdentifiers() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean supportsANSI92EntryLevelSQL() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean supportsANSI92FullSQL() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean supportsANSI92IntermediateSQL() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean supportsAlterTableWithAddColumn() throws SQLException {
     return true;
   }
 
   public boolean supportsAlterTableWithDropColumn() throws SQLException {
     return false;
   }
 
   public boolean supportsBatchUpdates() throws SQLException {
     return false;
   }
 
   public boolean supportsCatalogsInDataManipulation() throws SQLException {
     return false;
   }
 
   public boolean supportsCatalogsInIndexDefinitions() throws SQLException {
     return false;
   }
 
   public boolean supportsCatalogsInPrivilegeDefinitions() throws SQLException {
     return false;
   }
 
   public boolean supportsCatalogsInProcedureCalls() throws SQLException {
     return false;
   }
 
   public boolean supportsCatalogsInTableDefinitions() throws SQLException {
     return false;
   }
 
   public boolean supportsColumnAliasing() throws SQLException {
     return true;
   }
 
   public boolean supportsConvert() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean supportsConvert(int fromTypeint toTypethrows SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean supportsCoreSQLGrammar() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean supportsCorrelatedSubqueries() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
       throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean supportsDataManipulationTransactionsOnly() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean supportsDifferentTableCorrelationNames() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean supportsExpressionsInOrderBy() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean supportsExtendedSQLGrammar() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean supportsFullOuterJoins() throws SQLException {
     return true;
   }
 
   public boolean supportsGetGeneratedKeys() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean supportsGroupBy() throws SQLException {
     return true;
   }
 
   public boolean supportsGroupByBeyondSelect() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean supportsGroupByUnrelated() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean supportsIntegrityEnhancementFacility() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean supportsLikeEscapeClause() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean supportsLimitedOuterJoins() throws SQLException {
     return true;
   }
 
   public boolean supportsMinimumSQLGrammar() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean supportsMixedCaseIdentifiers() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean supportsMixedCaseQuotedIdentifiers() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean supportsMultipleOpenResults() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean supportsMultipleResultSets() throws SQLException {
     return false;
   }
 
   public boolean supportsMultipleTransactions() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean supportsNamedParameters() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean supportsNonNullableColumns() throws SQLException {
     return false;
   }
 
   public boolean supportsOpenCursorsAcrossCommit() throws SQLException {
     throw new SQLException("Method not supported");
   }
 
   public boolean supportsOpenCursorsAcrossRollback() throws SQLException {
     throw new SQLException("Method not supported");
  }
  public boolean supportsOpenStatementsAcrossCommit() throws SQLException {
    throw new SQLException("Method not supported");
  }
  public boolean supportsOpenStatementsAcrossRollback() throws SQLException {
    throw new SQLException("Method not supported");
  }
  public boolean supportsOrderByUnrelated() throws SQLException {
    throw new SQLException("Method not supported");
  }
  public boolean supportsOuterJoins() throws SQLException {
    return true;
  }
  public boolean supportsPositionedDelete() throws SQLException {
    return false;
  }
  public boolean supportsPositionedUpdate() throws SQLException {
    return false;
  }
  public boolean supportsResultSetConcurrency(int typeint concurrency)
      throws SQLException {
    throw new SQLException("Method not supported");
  }
  public boolean supportsResultSetHoldability(int holdability)
      throws SQLException {
    return false;
  }
  public boolean supportsResultSetType(int typethrows SQLException {
    return true;
  }
  public boolean supportsSavepoints() throws SQLException {
    return false;
  }
  public boolean supportsSchemasInDataManipulation() throws SQLException {
    return true;
  }
  public boolean supportsSchemasInIndexDefinitions() throws SQLException {
    return false;
  }
  public boolean supportsSchemasInPrivilegeDefinitions() throws SQLException {
    return false;
  }
  public boolean supportsSchemasInProcedureCalls() throws SQLException {
    return false;
  }