All Libraries | This Library | Package | Class | Use | Tree | Deprecated | Index | Grand Index | Help
|  | Components |
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## com.sas.net.sharenet
Class ShareNetDatabaseMetaData

    com.sas.net.sharenet.ShareNetDatabaseMetaData

All Implemented Interfaces:
  java.sql.DatabaseMetaData, java.sql.Wrapper

    public class ShareNetDatabaseMetaData

implements java.sql.DatabaseMetaData

This is the SAS/SHARE Driver for JDBC implementation for java.sql.DatabaseMetaData.

Field Summary
`protected short` | `sv`

Method Summary
`boolean` | `allProceduresAreCallable()` Determines whether all stored procedures are callable.
`boolean` | `allTablesAreSelectable()` Determines whether all accessible tables are selectable.
`boolean` | `autoCommitFailureClosesAllResultSets()` This method is not supported and will always throw a SQLException.
`boolean` | `dataDefinitionCausesTransactionCommit()` Determines whether a data definition statement within a transaction forces the transaction to commit.
`boolean` | `dataDefinitionIgnoredInTransactions()` Determines whether a data definition statement within a transaction is ignored.
`boolean` | `deletesAreDetected(int type)` This method is not supported and will always throw a SQLException.
`boolean` | `doesMaxRowSizeIncludeBlobs()` Determines whether getMaxRowSize() includes LONGVARCHAR and LONGVARBINARY blobs.
`java.sql.ResultSet` | `getAttributes(java.lang.String catalog, java.lang.String schemaPattern, java.lang.String typeNamePattern, java.lang.String attributeNamePattern)` This method is not supported and will always throw a SQLException.
`java.sql.ResultSet` | `getBestRowIdentifier(java.lang.String catalog, java.lang.String schema, java.lang.String table, int scope, boolean nullable)`
`java.sql.ResultSet` | `getCatalogs()` Gets the catalog names that are available in this database.
`java.lang.String` | `getCatalogSeparator()` Gets the separator that is being used between the catalog name and the table name.
`java.lang.String` | `getCatalogTerm()` Gets the preferred term for "catalog".
`java.sql.ResultSet` | `getClientInfoProperties()`
`java.sql.ResultSet` | `getColumnPrivileges(java.lang.String catalog, java.lang.String schema, java.lang.String table, java.lang.String columnNamePattern)` This method is not supported and will always throw a SQLException.
`java.sql.ResultSet` | `getColumns(java.lang.String catalog, java.lang.String schemaPattern, java.lang.String tableNamePattern, java.lang.String columnNamePattern)`
`java.sql.Connection` | `getConnection()` This method is not supported and will always throw a SQLException.
`java.sql.ResultSet` | `getCrossReference(java.lang.String primaryCatalog, java.lang.String primarySchema, java.lang.String primaryTable, java.lang.String foreignCatalog, java.lang.String foreignSchema, java.lang.String foreignTable)`
`int` | `getDatabaseMajorVersion()`
`int` | `getDatabaseMinorVersion()`
`java.lang.String` | `getDatabaseProductName()` Gets the database product name.
`java.lang.String` | `getDatabaseProductVersion()` Returns the version of the SAS/SHARE server.
`int` | `getDefaultTransactionIsolation()` Gets the default transaction isolation level for the database.
`int` | `getDriverMajorVersion()` Gets the driver major version number as an integer.
`int` | `getDriverMinorVersion()` Gets the driver minor version number as an integer.
`java.lang.String` | `getDriverName()` Gets the driver name and version number.
`java.lang.String` | `getDriverVersion()`
`java.sql.ResultSet` | `getExportedKeys(java.lang.String catalog, java.lang.String schema, java.lang.String table)`
`java.lang.String` | `getExtraNameCharacters()` Gets a string that contains all the "extra" characters that identier names can contain.
`java.sql.ResultSet` | `getFunctionColumns(java.lang.String catalog, java.lang.String schemaPattern, java.lang.String functionNamePattern, java.lang.String columnNamePattern)` This method is not supported and will always throw a SQLException.
`java.sql.ResultSet` | `getFunctions(java.lang.String catalog, java.lang.String schemaPattern, java.lang.String functionNamePattern)` This method is not supported and will always throw a SQLException.
`java.lang.String` | `getIdentifierQuoteString()` Gets the quote string that is used to surround quoted SQL identifiers.
`java.sql.ResultSet` | `getImportedKeys(java.lang.String catalog, java.lang.String schema, java.lang.String table)`
`java.sql.ResultSet` | `getIndexInfo(java.lang.String catalog, java.lang.String schema, java.lang.String table, boolean unique, boolean approximate)`
`int` | `getJDBCMajorVersion()` This method is not supported and will always throw a SQLException.
`int` | `getJDBCMinorVersion()` This method is not supported and will always throw a SQLException.
`int` | `getMaxBinaryLiteralLength()` Returns the number of hex characters that are allowed in an inline binary literal.
`int` | `getMaxCatalogNameLength()` Indicates the maximum length of a catalog name.
`int` | `getMaxCharLiteralLength()` Returns the maximum length of a character literal.
`int` | `getMaxColumnNameLength()` Returns the maximum length of a column name.
`int` | `getMaxColumnsInGroupBy()` Indicates the maximum number of columns that are allowed in a GROUP BY clause.
`int` | `getMaxColumnsInIndex()` Indicates the maximum number of columns that are allowed in an index.
`int` | `getMaxColumnsInOrderBy()` Indicates the maximum number of columns that are allowed in an ORDER BY clause.
`int` | `getMaxColumnsInSelect()` Determines the maximum number of columns that are allowed in a SELECT list.
`int` | `getMaxColumnsInTable()` Indicates the maximum number of columns that are allowed in a table.
`int` | `getMaxConnections()` Indicates the maximum number of database connections that can be active concurrently.
`int` | `getMaxCursorNameLength()` Indicates the maximum length of a cursor name.
`int` | `getMaxIndexLength()` Indicates the maximum size of an index (in bytes).
`int` | `getMaxProcedureNameLength()` Indicates the maximum length of a procedure name.
`int` | `getMaxRowSize()` Indicates the maximum length of a single row.
`int` | `getMaxSchemaNameLength()` Indicates the maximum length of a schema name.
`int` | `getMaxStatementLength()` Indicates the maximum length of an SQL statement.
`int` | `getMaxStatements()` Indicates the maximum number of active statements that can be open to this database concurrently.
`int` | `getMaxTableNameLength()` Indicates the maximum length of a table name.
`int` | `getMaxTablesInSelect()` Indicates the maximum number of tables in a SELECT list.
`int` | `getMaxUserNameLength()` Indicates the maximum length of a user name.
`java.lang.String` | `getNumericFunctions()` Gets a comma-delimited list of math functions.
`java.sql.ResultSet` | `getPrimaryKeys(java.lang.String catalog, java.lang.String schema, java.lang.String table)`
`java.sql.ResultSet` | `getProcedureColumns(java.lang.String catalog, java.lang.String schemaPattern, java.lang.String procedureNamePattern, java.lang.String columnNamePattern)` Gets a description of a catalog's stored procedure parameters and result columns.
`java.sql.ResultSet` | `getProcedures(java.lang.String catalog, java.lang.String schemaPattern, java.lang.String procedureNamePattern)` Get a description of stored procedures available in a catalog.
`java.lang.String` | `getProcedureTerm()` Gets the preferred term for "procedure".
`int` | `getResultSetHoldability()` This method is not supported and will always throw a SQLException.
`java.sql.RowIdLifetime` | `getRowIdLifetime()` This method is not supported and will always throw a SQLException.
`java.sql.ResultSet` | `getSchemas()`
`java.sql.ResultSet` | `getSchemas(java.lang.String catalog, java.lang.String schemaPattern)`
`java.lang.String` | `getSchemaTerm()` Gets the preferred term for "schema".
`java.lang.String` | `getSearchStringEscape()` Gets the string that can be used to escape an underscore (_) or a percentage sign (%) in string based searches such as getTables().
`java.lang.String` | `getSQLKeywords()` Gets a comma-delimited list of all database-specific SQL keywords that are not SQL92 keywords.
`int` | `getSQLStateType()` This method is not supported and will always throw a SQLException.
`java.lang.String` | `getStringFunctions()` Gets a comma-delimited list of string functions.
`java.sql.ResultSet` | `getSuperTables(java.lang.String catalog, java.lang.String schemaPattern, java.lang.String tableNamePattern)` This method is not supported and will always throw a SQLException.
`java.sql.ResultSet` | `getSuperTypes(java.lang.String catalog, java.lang.String schemaPattern, java.lang.String typeNamePattern)` This method is not supported and will always throw a SQLException.
`java.lang.String` | `getSystemFunctions()` Gets a comma-delimited list of system functions.
`java.sql.ResultSet` | `getTablePrivileges(java.lang.String catalog, java.lang.String schemaPattern, java.lang.String tableNamePattern)` This method is not supported and will always throw a SQLException.
`java.sql.ResultSet` | `getTables(java.lang.String catalog, java.lang.String schemaPattern, java.lang.String tableNamePattern, java.lang.String[] types)`
`java.sql.ResultSet` | `getTableTypes()`
`java.lang.String` | `getTimeDateFunctions()` Gets a comma-delimited list of time and date functions.
`java.sql.ResultSet` | `getTypeInfo()`
`java.sql.ResultSet` | `getUDTs(java.lang.String catalog, java.lang.String schemaPattern, java.lang.String typeNamePattern, int[] types)` This method is not supported and will always throw a SQLException.
`java.lang.String` | `getURL()` Gets the URL from the ShareNetConnection object.
`java.lang.String` | `getUserName()` Gets the user name from the ShareNetConnection object.
`java.sql.ResultSet` | `getVersionColumns(java.lang.String catalog, java.lang.String schema, java.lang.String table)` This method is not supported and will always throw a SQLException.
`boolean` | `insertsAreDetected(int type)` This method is not supported and will always throw a SQLException.
`boolean` | `isCatalogAtStart()` Determines whether a catalog appears at the start of a qualified table name.
`boolean` | `isReadOnly()` Determines whether the connection is read-only.
`boolean` | `isWrapperFor(java.lang.Class<?> iface)`
`boolean` | `locatorsUpdateCopy()` This method is not supported and will always throw a SQLException.
`boolean` | `nullPlusNonNullIsNull()` Determines whether the concatenations between NULL and non-NULL values are NULL.
`boolean` | `nullsAreSortedAtEnd()` Determines whether NULLs are sorted at end.
`boolean` | `nullsAreSortedAtStart()` Determines whether NULLs are sorted at start.
`boolean` | `nullsAreSortedHigh()` Determines whether NULLs are sorted high.
`boolean` | `nullsAreSortedLow()` Determines whether NULLs are sorted low.
`boolean` | `othersDeletesAreVisible(int type)` This method is not supported and will always throw a SQLException.
`boolean` | `othersInsertsAreVisible(int type)` This method is not supported and will always throw a SQLException.
`boolean` | `othersUpdatesAreVisible(int type)` This method is not supported and will always throw a SQLException.
`boolean` | `ownDeletesAreVisible(int type)` This method is not supported and will always throw a SQLException.
`boolean` | `ownInsertsAreVisible(int type)` This method is not supported and will always throw a SQLException.
`boolean` | `ownUpdatesAreVisible(int type)` This method is not supported and will always throw a SQLException.
`boolean` | `storesLowerCaseIdentifiers()` Determines whether the database stores lowercase identifiers.
`boolean` | `storesLowerCaseQuotedIdentifiers()` Determines whether the database stores lowercase quoted SQL identifiers.
`boolean` | `storesMixedCaseIdentifiers()` Determines whether the database stores mixed-case identifiers.
`boolean` | `storesMixedCaseQuotedIdentifiers()` Determines whether the database stores mixed-case quoted SQL identifiers.
`boolean` | `storesUpperCaseIdentifiers()` Determines whether the database stores uppercase identifiers.
`boolean` | `storesUpperCaseQuotedIdentifiers()` Determines whether the database stores uppercase quoted SQL identifiers.
`boolean` | `supportsAlterTableWithAddColumn()` Determines whether ALTER TABLE with an add column is supported.
`boolean` | `supportsAlterTableWithDropColumn()` Determines whether ALTER TABLE with a drop column is supported.
`boolean` | `supportsANSI92EntryLevelSQL()` Determines whether ANSI92 entry level SQL grammar is supported.
`boolean` | `supportsANSI92FullSQL()` Determines whether ANSI92 full SQL grammar is supported.
`boolean` | `supportsANSI92IntermediateSQL()` Determines whether ANSI92 intermediate SQL grammar is supported.
`boolean` | `supportsBatchUpdates()`
`boolean` | `supportsCatalogsInDataManipulation()` Determines whether a data manipulation statement can contain a catalog name.
`boolean` | `supportsCatalogsInIndexDefinitions()` Determines whether an index definition statement can contain a catalog name.
`boolean` | `supportsCatalogsInPrivilegeDefinitions()` Determines whether a privilege definition statement can contain a catalog name.
`boolean` | `supportsCatalogsInProcedureCalls()` Determines whether a procedure call statement can contain a catalog name.
`boolean` | `supportsCatalogsInTableDefinitions()` Determines whether a table definition statement can contain a catalog name.
`boolean` | `supportsColumnAliasing()` Determines whether column aliasing is supported.
`boolean` | `supportsConvert()` Determines whether the CONVERT function for conversions between SQL types is supported.
`boolean` | `supportsConvert(int fromType, int toType)` Determines whether the CONVERT function for conversions between the given SQL types from java.sql.Types is supported.
`boolean` | `supportsCoreSQLGrammar()` Determines whether the ODBC Core SQL grammar is supported.
`boolean` | `supportsCorrelatedSubqueries()` Determines whether correlated subqueries are supported.
`boolean` | `supportsDataDefinitionAndDataManipulationTransactions()` Determines whether both data definition and data manipulation statements within a transaction are supported.
`boolean` | `supportsDataManipulationTransactionsOnly()` Determines whether data manipulation statements within a transaction are supported.
`boolean` | `supportsDifferentTableCorrelationNames()` When table correlation names are supported, determines whether table correlation names must be different from the table names.
`boolean` | `supportsExpressionsInOrderBy()` Determines whether expressions are supported in "ORDER BY" lists.
`boolean` | `supportsExtendedSQLGrammar()` Determines whether the ODBC Extended SQL grammar is supported.
`boolean` | `supportsFullOuterJoins()` Determines whether full, nested outer joins are supported.
`boolean` | `supportsGetGeneratedKeys()` This method is not supported and will always throw a SQLException.
`boolean` | `supportsGroupBy()` Determines whether some form of the GROUP BY clause is supported.
`boolean` | `supportsGroupByBeyondSelect()` Determines whether a GROUP BY clause can add columns that are not in the SELECT list.
`boolean` | `supportsGroupByUnrelated()` Detrmines whether GROUP BY clause can use columns that are not in the SELECT list.
`boolean` | `supportsIntegrityEnhancementFacility()` Determines whether the SQL Integrity Enhancement Facility is supported.
`boolean` | `supportsLikeEscapeClause()` Determines whether the escape character in LIKE clauses is supported.
`boolean` | `supportsLimitedOuterJoins()` Determines whether there is limited support for outer joins.
`boolean` | `supportsMinimumSQLGrammar()` Determines whether the ODBC Minimum SQL grammar is supported.
`boolean` | `supportsMixedCaseIdentifiers()` Determines whether the database supports mixed-case, unquoted SQL identifiers.
`boolean` | `supportsMixedCaseQuotedIdentifiers()` Determines whether the database supports mixed-case quoted SQL identifiers.
`boolean` | `supportsMultipleOpenResults()` This method is not supported and will always throw a SQLException.
`boolean` | `supportsMultipleResultSets()` Determines whether mulitple ResultSets from a single execute are supported.
`boolean` | `supportsMultipleTransactions()` Determines whether multiple transactions can be open concurrently.
`boolean` | `supportsNamedParameters()` This method is not supported and will always throw a SQLException.
`boolean` | `supportsNonNullableColumns()` Determines whether columns can support NULLs.
`boolean` | `supportsOpenCursorsAcrossCommit()` Determines whether cursors can remain open across commits.
`boolean` | `supportsOpenCursorsAcrossRollback()` Determines whether cursors can remain open across rollback.
`boolean` | `supportsOpenStatementsAcrossCommit()` Determines whether statements can remain open across commits.
`boolean` | `supportsOpenStatementsAcrossRollback()` Determines whether statements can remain open across rollbacks.
`boolean` | `supportsOrderByUnrelated()` Determines whether an ORDER BY clause can use columns that are not in the SELECT list.
`boolean` | `supportsOuterJoins()` Determines whether some form of outer join is supported.
`boolean` | `supportsPositionedDelete()` Determines whether positioned DELETE is supported.
`boolean` | `supportsPositionedUpdate()` Determines whether positioned UPDATE is supported.
`boolean` | `supportsResultSetConcurrency(int type, int concurrency)`
`boolean` | `supportsResultSetHoldability(int holdability)` This method is not supported and will always throw a SQLException.
`boolean` | `supportsResultSetType(int type)`
`boolean` | `supportsSavepoints()` This method is not supported and will always throw a SQLException.
`boolean` | `supportsSchemasInDataManipulation()` Determines whether a data manipulation statementcaon contain a schema name.
`boolean` | `supportsSchemasInIndexDefinitions()` Determines whether an index definition statement can contain a schema name.
`boolean` | `supportsSchemasInPrivilegeDefinitions()` Determines whether a privilege definition statement can contain a schema name.
`boolean` | `supportsSchemasInProcedureCalls()` Determines whether a procedure call statement can contain a schema name.
`boolean` | `supportsSchemasInTableDefinitions()` Determines whether a table definition statement can contain a schema name.
`boolean` | `supportsSelectForUpdate()` Determines whether SELECT for UPDATE is supported.
`boolean` | `supportsStatementPooling()` This method is not supported and will always throw a SQLException.
`boolean` | `supportsStoredFunctionsUsingCallSyntax()` This method is not supported and will always throw a SQLException.
`boolean` | `supportsStoredProcedures()` Determines whether stored procedure calls that use the stored procedure escape syntax are supported.
`boolean` | `supportsSubqueriesInComparisons()` Determines whether subqueries in comparison expressions are supported.
`boolean` | `supportsSubqueriesInExists()` Determines whether subqueries in exists expressions are supported.
`boolean` | `supportsSubqueriesInIns()` Determines whether subqueries in "in" statements are supported.
`boolean` | `supportsSubqueriesInQuantifieds()` Determines whether subqueries in quantified expressions are supported.
`boolean` | `supportsTableCorrelationNames()` Determines whether table correlation names are supported.
`boolean` | `supportsTransactionIsolationLevel(int level)` Determines whether the database supports the transaction isolation level.
`boolean` | `supportsTransactions()` Determines whether transactions are supported.
`boolean` | `supportsUnion()` Determines whether an SQL UNION is supported.
`boolean` | `supportsUnionAll()` Determines whether an SQL UNION ALL is supported.
`
`<T> T`
` | `unwrap(java.lang.Class<T> iface)`
`boolean` | `updatesAreDetected(int type)` This method is not supported and will always throw a SQLException.
`boolean` | `usesLocalFilePerTable()` Determines whether the database uses a file for each table.
`boolean` | `usesLocalFiles()` Determines whether the database stores each table in a local file.

Field Detail

### sv

    protected short sv

Method Detail

### allProceduresAreCallable

    public boolean allProceduresAreCallable()
                                     throws java.sql.SQLException

  Determines whether all stored procedures are callable.

  Specified by:
    `allProceduresAreCallable` in interface `java.sql.DatabaseMetaData`
  Returns:
    False. SAS software does not support stored procedures.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### allTablesAreSelectable

    public boolean allTablesAreSelectable()
                                   throws java.sql.SQLException

  Determines whether all accessible tables are selectable.

  Specified by:
    `allTablesAreSelectable` in interface `java.sql.DatabaseMetaData`
  Returns:
    True. All accessable tables are selectable.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### getURL

    public java.lang.String getURL()
                            throws java.sql.SQLException

  Gets the URL from the ShareNetConnection object.

  Specified by:
    `getURL` in interface `java.sql.DatabaseMetaData`
  Returns:
    The URL that is obtained from the ShareNetConnection object.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### getUserName

    public java.lang.String getUserName()
                                 throws java.sql.SQLException

  Gets the user name from the ShareNetConnection object.

  Specified by:
    `getUserName` in interface `java.sql.DatabaseMetaData`
  Returns:
    The user name that is obtained from ShareNetConnection object.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### isReadOnly

    public boolean isReadOnly()
                       throws java.sql.SQLException

  Determines whether the connection is read-only.

  Specified by:
    `isReadOnly` in interface `java.sql.DatabaseMetaData`
  Returns:
    False. SAS software does not support read-only connections.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### nullsAreSortedHigh

    public boolean nullsAreSortedHigh()
                               throws java.sql.SQLException

  Determines whether NULLs are sorted high.

  Specified by:
    `nullsAreSortedHigh` in interface `java.sql.DatabaseMetaData`
  Returns:
    False. NULLs are sorted low.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### nullsAreSortedLow

    public boolean nullsAreSortedLow()
                              throws java.sql.SQLException

  Determines whether NULLs are sorted low.

  Specified by:
    `nullsAreSortedLow` in interface `java.sql.DatabaseMetaData`
  Returns:
    True. NULLs are sorted low.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### nullsAreSortedAtStart

    public boolean nullsAreSortedAtStart()
                                  throws java.sql.SQLException

  Determines whether NULLs are sorted at start.

  Specified by:
    `nullsAreSortedAtStart` in interface `java.sql.DatabaseMetaData`
  Returns:
    False. NULLs are sorted low
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### nullsAreSortedAtEnd

    public boolean nullsAreSortedAtEnd()
                                throws java.sql.SQLException

  Determines whether NULLs are sorted at end.

  Specified by:
    `nullsAreSortedAtEnd` in interface `java.sql.DatabaseMetaData`
  Returns:
    False. NULLs are sorted low
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### getDatabaseProductName

    public java.lang.String getDatabaseProductName()
                                            throws java.sql.SQLException

  Gets the database product name.

  Specified by:
    `getDatabaseProductName` in interface `java.sql.DatabaseMetaData`
  Returns:
    The string "SAS".
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### getDatabaseProductVersion

    public java.lang.String getDatabaseProductVersion()
                                               throws java.sql.SQLException

  Returns the version of the SAS/SHARE server.

  Specified by:
    `getDatabaseProductVersion` in interface `java.sql.DatabaseMetaData`
  Returns:
    A string that contains the version number from the SAS/SHARE server.
  Throws:
    `java.sql.SQLException` - This exception is thrown if a ShareNet exception is detected or if the server does not respond.

### getDriverName

    public java.lang.String getDriverName()
                                   throws java.sql.SQLException

  Gets the driver name and version number.

  Specified by:
    `getDriverName` in interface `java.sql.DatabaseMetaData`
  Returns:
    the driver name and version number
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### getDriverVersion

    public java.lang.String getDriverVersion()
                                      throws java.sql.SQLException

  Specified by:
    `getDriverVersion` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### getDriverMajorVersion

    public int getDriverMajorVersion()

  Gets the driver major version number as an integer.

  Specified by:
    `getDriverMajorVersion` in interface `java.sql.DatabaseMetaData`
  Returns:
    the driver major version number as an integer

### getDriverMinorVersion

    public int getDriverMinorVersion()

  Gets the driver minor version number as an integer.

  Specified by:
    `getDriverMinorVersion` in interface `java.sql.DatabaseMetaData`
  Returns:
    the driver minor version number as an integer

### usesLocalFiles

    public boolean usesLocalFiles()
                           throws java.sql.SQLException

  Determines whether the database stores each table in a local file.

  Specified by:
    `usesLocalFiles` in interface `java.sql.DatabaseMetaData`
  Returns:
    False.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### usesLocalFilePerTable

    public boolean usesLocalFilePerTable()
                                  throws java.sql.SQLException

  Determines whether the database uses a file for each table.

  Specified by:
    `usesLocalFilePerTable` in interface `java.sql.DatabaseMetaData`
  Returns:
    False.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsMixedCaseIdentifiers

    public boolean supportsMixedCaseIdentifiers()
                                         throws java.sql.SQLException

  Determines whether the database supports mixed-case, unquoted SQL identifiers.

  Specified by:
    `supportsMixedCaseIdentifiers` in interface `java.sql.DatabaseMetaData`
  Returns:
    False.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### storesUpperCaseIdentifiers

    public boolean storesUpperCaseIdentifiers()
                                       throws java.sql.SQLException

  Determines whether the database stores uppercase identifiers.

  Specified by:
    `storesUpperCaseIdentifiers` in interface `java.sql.DatabaseMetaData`
  Returns:
    True if the SAS server is a V6 server else return false if its a V7 server.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### storesLowerCaseIdentifiers

    public boolean storesLowerCaseIdentifiers()
                                       throws java.sql.SQLException

  Determines whether the database stores lowercase identifiers.

  Specified by:
    `storesLowerCaseIdentifiers` in interface `java.sql.DatabaseMetaData`
  Returns:
    False.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### storesMixedCaseIdentifiers

    public boolean storesMixedCaseIdentifiers()
                                       throws java.sql.SQLException

  Determines whether the database stores mixed-case identifiers.

  Specified by:
    `storesMixedCaseIdentifiers` in interface `java.sql.DatabaseMetaData`
  Returns:
    False if the SAS server is a V6 server else return true if its a V7 server.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsMixedCaseQuotedIdentifiers

    public boolean supportsMixedCaseQuotedIdentifiers()
                                               throws java.sql.SQLException

  Determines whether the database supports mixed-case quoted SQL identifiers.

  Specified by:
    `supportsMixedCaseQuotedIdentifiers` in interface `java.sql.DatabaseMetaData`
  Returns:
    False.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### storesUpperCaseQuotedIdentifiers

    public boolean storesUpperCaseQuotedIdentifiers()
                                             throws java.sql.SQLException

  Determines whether the database stores uppercase quoted SQL identifiers.

  Specified by:
    `storesUpperCaseQuotedIdentifiers` in interface `java.sql.DatabaseMetaData`
  Returns:
    False.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### storesLowerCaseQuotedIdentifiers

    public boolean storesLowerCaseQuotedIdentifiers()
                                             throws java.sql.SQLException

  Determines whether the database stores lowercase quoted SQL identifiers.

  Specified by:
    `storesLowerCaseQuotedIdentifiers` in interface `java.sql.DatabaseMetaData`
  Returns:
    False.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### storesMixedCaseQuotedIdentifiers

    public boolean storesMixedCaseQuotedIdentifiers()
                                             throws java.sql.SQLException

  Determines whether the database stores mixed-case quoted SQL identifiers.

  Specified by:
    `storesMixedCaseQuotedIdentifiers` in interface `java.sql.DatabaseMetaData`
  Returns:
    False.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### getIdentifierQuoteString

    public java.lang.String getIdentifierQuoteString()
                                              throws java.sql.SQLException

  Gets the quote string that is used to surround quoted SQL identifiers. SAS software does not support quoted identifiers, so a blank is returned.

  Specified by:
    `getIdentifierQuoteString` in interface `java.sql.DatabaseMetaData`
  Returns:
    A blank string (" ").
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### getSQLKeywords

    public java.lang.String getSQLKeywords()
                                    throws java.sql.SQLException

  Gets a comma-delimited list of all database-specific SQL keywords that are not SQL92 keywords.

  Specified by:
    `getSQLKeywords` in interface `java.sql.DatabaseMetaData`
  Returns:
    An empty string (""). No additional keywords are reserved.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### getNumericFunctions

    public java.lang.String getNumericFunctions()
                                         throws java.sql.SQLException

  Gets a comma-delimited list of math functions.

  Specified by:
    `getNumericFunctions` in interface `java.sql.DatabaseMetaData`
  Returns:
    The string "ABS, ACOS, ASIN, ATAN, CEILING, COS, EXP, FLOOR, LOG, LOG10, MOD, POWER, RAND, ROUND, SIGN, SIN, SQRT, TAN"
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### getStringFunctions

    public java.lang.String getStringFunctions()
                                        throws java.sql.SQLException

  Gets a comma-delimited list of string functions.

  Specified by:
    `getStringFunctions` in interface `java.sql.DatabaseMetaData`
  Returns:
    The string "ASCII, CHAR, CONCAT, LCASE, LEFT, LTRIM, REPEAT, REPLACE, RTRIM, SOUNDEX, SPACE, SUBSTRING, UCASE"
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### getSystemFunctions

    public java.lang.String getSystemFunctions()
                                        throws java.sql.SQLException

  Gets a comma-delimited list of system functions. SAS software does not support any system functions, so an empty string is returned.

  Specified by:
    `getSystemFunctions` in interface `java.sql.DatabaseMetaData`
  Returns:
    An empty string ("").
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### getTimeDateFunctions

    public java.lang.String getTimeDateFunctions()
                                          throws java.sql.SQLException

  Gets a comma-delimited list of time and date functions.

  Specified by:
    `getTimeDateFunctions` in interface `java.sql.DatabaseMetaData`
  Returns:
    The string "CURDATE, CURTIME, DAYNAME, DAYOFMONTH, DAYOFWEEK, DAYOFYEAR, HOUR, MINUTE, MONTH, MONTHNAME, NOW, QUARTER, SECOND, YEAR"
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### getSearchStringEscape

    public java.lang.String getSearchStringEscape()
                                           throws java.sql.SQLException

  Gets the string that can be used to escape an underscore (_) or a percentage sign (%) in string based searches such as getTables(). SAS software does not support any escape characters for schema or table names, so an empty string is returned.

  Specified by:
    `getSearchStringEscape` in interface `java.sql.DatabaseMetaData`
  Returns:
    An empty string ("").
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### getExtraNameCharacters

    public java.lang.String getExtraNameCharacters()
                                            throws java.sql.SQLException

  Gets a string that contains all the "extra" characters that identier names can contain. SAS software does not support any additional characters for names, so an empty string is returned.

  Specified by:
    `getExtraNameCharacters` in interface `java.sql.DatabaseMetaData`
  Returns:
    An empty string ("").
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsAlterTableWithAddColumn

    public boolean supportsAlterTableWithAddColumn()
                                            throws java.sql.SQLException

  Determines whether ALTER TABLE with an add column is supported.

  Specified by:
    `supportsAlterTableWithAddColumn` in interface `java.sql.DatabaseMetaData`
  Returns:
    True.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsAlterTableWithDropColumn

    public boolean supportsAlterTableWithDropColumn()
                                             throws java.sql.SQLException

  Determines whether ALTER TABLE with a drop column is supported.

  Specified by:
    `supportsAlterTableWithDropColumn` in interface `java.sql.DatabaseMetaData`
  Returns:
    True.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsColumnAliasing

    public boolean supportsColumnAliasing()
                                   throws java.sql.SQLException

  Determines whether column aliasing is supported.

  Specified by:
    `supportsColumnAliasing` in interface `java.sql.DatabaseMetaData`
  Returns:
    True.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### nullPlusNonNullIsNull

    public boolean nullPlusNonNullIsNull()
                                  throws java.sql.SQLException

  Determines whether the concatenations between NULL and non-NULL values are NULL.

  Specified by:
    `nullPlusNonNullIsNull` in interface `java.sql.DatabaseMetaData`
  Returns:
    False.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsConvert

    public boolean supportsConvert()
                            throws java.sql.SQLException

  Determines whether the CONVERT function for conversions between SQL types is supported.

  Specified by:
    `supportsConvert` in interface `java.sql.DatabaseMetaData`
  Returns:
    False.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsConvert

    public boolean supportsConvert(int fromType,
                                   int toType)
                            throws java.sql.SQLException

  Determines whether the CONVERT function for conversions between the given SQL types from java.sql.Types is supported.

  Specified by:
    `supportsConvert` in interface `java.sql.DatabaseMetaData`
  Returns:
    False.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsTableCorrelationNames

    public boolean supportsTableCorrelationNames()
                                          throws java.sql.SQLException

  Determines whether table correlation names are supported.

  Specified by:
    `supportsTableCorrelationNames` in interface `java.sql.DatabaseMetaData`
  Returns:
    True.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsDifferentTableCorrelationNames

    public boolean supportsDifferentTableCorrelationNames()
                                                   throws java.sql.SQLException

  When table correlation names are supported, determines whether table correlation names must be different from the table names.

  Specified by:
    `supportsDifferentTableCorrelationNames` in interface `java.sql.DatabaseMetaData`
  Returns:
    False.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsExpressionsInOrderBy

    public boolean supportsExpressionsInOrderBy()
                                         throws java.sql.SQLException

  Determines whether expressions are supported in "ORDER BY" lists.

  Specified by:
    `supportsExpressionsInOrderBy` in interface `java.sql.DatabaseMetaData`
  Returns:
    True.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsOrderByUnrelated

    public boolean supportsOrderByUnrelated()
                                     throws java.sql.SQLException

  Determines whether an ORDER BY clause can use columns that are not in the SELECT list.

  Specified by:
    `supportsOrderByUnrelated` in interface `java.sql.DatabaseMetaData`
  Returns:
    True.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsGroupBy

    public boolean supportsGroupBy()
                            throws java.sql.SQLException

  Determines whether some form of the GROUP BY clause is supported.

  Specified by:
    `supportsGroupBy` in interface `java.sql.DatabaseMetaData`
  Returns:
    True.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsGroupByUnrelated

    public boolean supportsGroupByUnrelated()
                                     throws java.sql.SQLException

  Detrmines whether GROUP BY clause can use columns that are not in the SELECT list.

  Specified by:
    `supportsGroupByUnrelated` in interface `java.sql.DatabaseMetaData`
  Returns:
    True.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsGroupByBeyondSelect

    public boolean supportsGroupByBeyondSelect()
                                        throws java.sql.SQLException

  Determines whether a GROUP BY clause can add columns that are not in the SELECT list.

  Specified by:
    `supportsGroupByBeyondSelect` in interface `java.sql.DatabaseMetaData`
  Returns:
    True.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsLikeEscapeClause

    public boolean supportsLikeEscapeClause()
                                     throws java.sql.SQLException

  Determines whether the escape character in LIKE clauses is supported.

  Specified by:
    `supportsLikeEscapeClause` in interface `java.sql.DatabaseMetaData`
  Returns:
    False.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsMultipleResultSets

    public boolean supportsMultipleResultSets()
                                       throws java.sql.SQLException

  Determines whether mulitple ResultSets from a single execute are supported.

  Specified by:
    `supportsMultipleResultSets` in interface `java.sql.DatabaseMetaData`
  Returns:
    False.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsMultipleTransactions

    public boolean supportsMultipleTransactions()
                                         throws java.sql.SQLException

  Determines whether multiple transactions can be open concurrently.

  Specified by:
    `supportsMultipleTransactions` in interface `java.sql.DatabaseMetaData`
  Returns:
    False.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsNonNullableColumns

    public boolean supportsNonNullableColumns()
                                       throws java.sql.SQLException

  Determines whether columns can support NULLs.

  Specified by:
    `supportsNonNullableColumns` in interface `java.sql.DatabaseMetaData`
  Returns:
    True.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsMinimumSQLGrammar

    public boolean supportsMinimumSQLGrammar()
                                      throws java.sql.SQLException

  Determines whether the ODBC Minimum SQL grammar is supported.

  Specified by:
    `supportsMinimumSQLGrammar` in interface `java.sql.DatabaseMetaData`
  Returns:
    True.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsCoreSQLGrammar

    public boolean supportsCoreSQLGrammar()
                                   throws java.sql.SQLException

  Determines whether the ODBC Core SQL grammar is supported.

  Specified by:
    `supportsCoreSQLGrammar` in interface `java.sql.DatabaseMetaData`
  Returns:
    False.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsExtendedSQLGrammar

    public boolean supportsExtendedSQLGrammar()
                                       throws java.sql.SQLException

  Determines whether the ODBC Extended SQL grammar is supported.

  Specified by:
    `supportsExtendedSQLGrammar` in interface `java.sql.DatabaseMetaData`
  Returns:
    False.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsANSI92EntryLevelSQL

    public boolean supportsANSI92EntryLevelSQL()
                                        throws java.sql.SQLException

  Determines whether ANSI92 entry level SQL grammar is supported.

  Specified by:
    `supportsANSI92EntryLevelSQL` in interface `java.sql.DatabaseMetaData`
  Returns:
    True.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsANSI92IntermediateSQL

    public boolean supportsANSI92IntermediateSQL()
                                          throws java.sql.SQLException

  Determines whether ANSI92 intermediate SQL grammar is supported.

  Specified by:
    `supportsANSI92IntermediateSQL` in interface `java.sql.DatabaseMetaData`
  Returns:
    False.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsANSI92FullSQL

    public boolean supportsANSI92FullSQL()
                                  throws java.sql.SQLException

  Determines whether ANSI92 full SQL grammar is supported.

  Specified by:
    `supportsANSI92FullSQL` in interface `java.sql.DatabaseMetaData`
  Returns:
    False
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsIntegrityEnhancementFacility

    public boolean supportsIntegrityEnhancementFacility()
                                                 throws java.sql.SQLException

  Determines whether the SQL Integrity Enhancement Facility is supported.

  Specified by:
    `supportsIntegrityEnhancementFacility` in interface `java.sql.DatabaseMetaData`
  Returns:
    False.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsOuterJoins

    public boolean supportsOuterJoins()
                               throws java.sql.SQLException

  Determines whether some form of outer join is supported.

  Specified by:
    `supportsOuterJoins` in interface `java.sql.DatabaseMetaData`
  Returns:
    True.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsFullOuterJoins

    public boolean supportsFullOuterJoins()
                                   throws java.sql.SQLException

  Determines whether full, nested outer joins are supported.

  Specified by:
    `supportsFullOuterJoins` in interface `java.sql.DatabaseMetaData`
  Returns:
    True.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsLimitedOuterJoins

    public boolean supportsLimitedOuterJoins()
                                      throws java.sql.SQLException

  Determines whether there is limited support for outer joins.

  Specified by:
    `supportsLimitedOuterJoins` in interface `java.sql.DatabaseMetaData`
  Returns:
    True.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### getSchemaTerm

    public java.lang.String getSchemaTerm()
                                   throws java.sql.SQLException

  Gets the preferred term for "schema".

  Specified by:
    `getSchemaTerm` in interface `java.sql.DatabaseMetaData`
  Returns:
    The string "library".
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### getProcedureTerm

    public java.lang.String getProcedureTerm()
                                      throws java.sql.SQLException

  Gets the preferred term for "procedure".

  Specified by:
    `getProcedureTerm` in interface `java.sql.DatabaseMetaData`
  Returns:
    An empty string ("").
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### getCatalogTerm

    public java.lang.String getCatalogTerm()
                                    throws java.sql.SQLException

  Gets the preferred term for "catalog".

  Specified by:
    `getCatalogTerm` in interface `java.sql.DatabaseMetaData`
  Returns:
    An empty string ("").
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### isCatalogAtStart

    public boolean isCatalogAtStart()
                             throws java.sql.SQLException

  Determines whether a catalog appears at the start of a qualified table name.

  Specified by:
    `isCatalogAtStart` in interface `java.sql.DatabaseMetaData`
  Returns:
    False.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### getCatalogSeparator

    public java.lang.String getCatalogSeparator()
                                         throws java.sql.SQLException

  Gets the separator that is being used between the catalog name and the table name.

  Specified by:
    `getCatalogSeparator` in interface `java.sql.DatabaseMetaData`
  Returns:
    An empty string ("").
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsSchemasInDataManipulation

    public boolean supportsSchemasInDataManipulation()
                                              throws java.sql.SQLException

  Determines whether a data manipulation statementcaon contain a schema name.

  Specified by:
    `supportsSchemasInDataManipulation` in interface `java.sql.DatabaseMetaData`
  Returns:
    True.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsSchemasInProcedureCalls

    public boolean supportsSchemasInProcedureCalls()
                                            throws java.sql.SQLException

  Determines whether a procedure call statement can contain a schema name.

  Specified by:
    `supportsSchemasInProcedureCalls` in interface `java.sql.DatabaseMetaData`
  Returns:
    False. SAS software does not support stored procedures.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsSchemasInTableDefinitions

    public boolean supportsSchemasInTableDefinitions()
                                              throws java.sql.SQLException

  Determines whether a table definition statement can contain a schema name.

  Specified by:
    `supportsSchemasInTableDefinitions` in interface `java.sql.DatabaseMetaData`
  Returns:
    True.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsSchemasInIndexDefinitions

    public boolean supportsSchemasInIndexDefinitions()
                                              throws java.sql.SQLException

  Determines whether an index definition statement can contain a schema name.

  Specified by:
    `supportsSchemasInIndexDefinitions` in interface `java.sql.DatabaseMetaData`
  Returns:
    True.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsSchemasInPrivilegeDefinitions

    public boolean supportsSchemasInPrivilegeDefinitions()
                                                  throws java.sql.SQLException

  Determines whether a privilege definition statement can contain a schema name.

  Specified by:
    `supportsSchemasInPrivilegeDefinitions` in interface `java.sql.DatabaseMetaData`
  Returns:
    False. SAS software does not support privileges.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsCatalogsInDataManipulation

    public boolean supportsCatalogsInDataManipulation()
                                               throws java.sql.SQLException

  Determines whether a data manipulation statement can contain a catalog name.

  Specified by:
    `supportsCatalogsInDataManipulation` in interface `java.sql.DatabaseMetaData`
  Returns:
    False. SAS software does not support SQL catalogs.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsCatalogsInProcedureCalls

    public boolean supportsCatalogsInProcedureCalls()
                                             throws java.sql.SQLException

  Determines whether a procedure call statement can contain a catalog name.

  Specified by:
    `supportsCatalogsInProcedureCalls` in interface `java.sql.DatabaseMetaData`
  Returns:
    False. SAS software does not support SQL catalogs.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsCatalogsInTableDefinitions

    public boolean supportsCatalogsInTableDefinitions()
                                               throws java.sql.SQLException

  Determines whether a table definition statement can contain a catalog name.

  Specified by:
    `supportsCatalogsInTableDefinitions` in interface `java.sql.DatabaseMetaData`
  Returns:
    False. SAS software does not support SQL catalogs.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsCatalogsInIndexDefinitions

    public boolean supportsCatalogsInIndexDefinitions()
                                               throws java.sql.SQLException

  Determines whether an index definition statement can contain a catalog name.

  Specified by:
    `supportsCatalogsInIndexDefinitions` in interface `java.sql.DatabaseMetaData`
  Returns:
    False. SAS software does not support SQL catalogs.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsCatalogsInPrivilegeDefinitions

    public boolean supportsCatalogsInPrivilegeDefinitions()
                                                   throws java.sql.SQLException

  Determines whether a privilege definition statement can contain a catalog name.

  Specified by:
    `supportsCatalogsInPrivilegeDefinitions` in interface `java.sql.DatabaseMetaData`
  Returns:
    False. SAS software does not support SQL catalogs.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsPositionedDelete

    public boolean supportsPositionedDelete()
                                     throws java.sql.SQLException

  Determines whether positioned DELETE is supported.

  Specified by:
    `supportsPositionedDelete` in interface `java.sql.DatabaseMetaData`
  Returns:
    False.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsPositionedUpdate

    public boolean supportsPositionedUpdate()
                                     throws java.sql.SQLException

  Determines whether positioned UPDATE is supported.

  Specified by:
    `supportsPositionedUpdate` in interface `java.sql.DatabaseMetaData`
  Returns:
    False.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsSelectForUpdate

    public boolean supportsSelectForUpdate()
                                    throws java.sql.SQLException

  Determines whether SELECT for UPDATE is supported.

  Specified by:
    `supportsSelectForUpdate` in interface `java.sql.DatabaseMetaData`
  Returns:
    False.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsStoredProcedures

    public boolean supportsStoredProcedures()
                                     throws java.sql.SQLException

  Determines whether stored procedure calls that use the stored procedure escape syntax are supported.

  Specified by:
    `supportsStoredProcedures` in interface `java.sql.DatabaseMetaData`
  Returns:
    False.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsSubqueriesInComparisons

    public boolean supportsSubqueriesInComparisons()
                                            throws java.sql.SQLException

  Determines whether subqueries in comparison expressions are supported.

  Specified by:
    `supportsSubqueriesInComparisons` in interface `java.sql.DatabaseMetaData`
  Returns:
    True.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsSubqueriesInExists

    public boolean supportsSubqueriesInExists()
                                       throws java.sql.SQLException

  Determines whether subqueries in exists expressions are supported.

  Specified by:
    `supportsSubqueriesInExists` in interface `java.sql.DatabaseMetaData`
  Returns:
    True.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsSubqueriesInIns

    public boolean supportsSubqueriesInIns()
                                    throws java.sql.SQLException

  Determines whether subqueries in "in" statements are supported.

  Specified by:
    `supportsSubqueriesInIns` in interface `java.sql.DatabaseMetaData`
  Returns:
    True.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsSubqueriesInQuantifieds

    public boolean supportsSubqueriesInQuantifieds()
                                            throws java.sql.SQLException

  Determines whether subqueries in quantified expressions are supported.

  Specified by:
    `supportsSubqueriesInQuantifieds` in interface `java.sql.DatabaseMetaData`
  Returns:
    True.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsCorrelatedSubqueries

    public boolean supportsCorrelatedSubqueries()
                                         throws java.sql.SQLException

  Determines whether correlated subqueries are supported.

  Specified by:
    `supportsCorrelatedSubqueries` in interface `java.sql.DatabaseMetaData`
  Returns:
    True.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsUnion

    public boolean supportsUnion()
                          throws java.sql.SQLException

  Determines whether an SQL UNION is supported.

  Specified by:
    `supportsUnion` in interface `java.sql.DatabaseMetaData`
  Returns:
    True.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsUnionAll

    public boolean supportsUnionAll()
                             throws java.sql.SQLException

  Determines whether an SQL UNION ALL is supported.

  Specified by:
    `supportsUnionAll` in interface `java.sql.DatabaseMetaData`
  Returns:
    True.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsOpenCursorsAcrossCommit

    public boolean supportsOpenCursorsAcrossCommit()
                                            throws java.sql.SQLException

  Determines whether cursors can remain open across commits.

  Specified by:
    `supportsOpenCursorsAcrossCommit` in interface `java.sql.DatabaseMetaData`
  Returns:
    False. SAS software does not support transactions.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsOpenCursorsAcrossRollback

    public boolean supportsOpenCursorsAcrossRollback()
                                              throws java.sql.SQLException

  Determines whether cursors can remain open across rollback.

  Specified by:
    `supportsOpenCursorsAcrossRollback` in interface `java.sql.DatabaseMetaData`
  Returns:
    False. SAS software does not support transactions.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsOpenStatementsAcrossCommit

    public boolean supportsOpenStatementsAcrossCommit()
                                               throws java.sql.SQLException

  Determines whether statements can remain open across commits.

  Specified by:
    `supportsOpenStatementsAcrossCommit` in interface `java.sql.DatabaseMetaData`
  Returns:
    True.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsOpenStatementsAcrossRollback

    public boolean supportsOpenStatementsAcrossRollback()
                                                 throws java.sql.SQLException

  Determines whether statements can remain open across rollbacks.

  Specified by:
    `supportsOpenStatementsAcrossRollback` in interface `java.sql.DatabaseMetaData`
  Returns:
    True. SAS software does not support transactions.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### getMaxBinaryLiteralLength

    public int getMaxBinaryLiteralLength()
                                  throws java.sql.SQLException

  Returns the number of hex characters that are allowed in an inline binary literal.

  Specified by:
    `getMaxBinaryLiteralLength` in interface `java.sql.DatabaseMetaData`
  Returns:
    0. There is no limit.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### getMaxCharLiteralLength

    public int getMaxCharLiteralLength()
                                throws java.sql.SQLException

  Returns the maximum length of a character literal.

  Specified by:
    `getMaxCharLiteralLength` in interface `java.sql.DatabaseMetaData`
  Returns:
    200 if the SAS server is a V6 server else return 32767 if its a V7 server.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### getMaxColumnNameLength

    public int getMaxColumnNameLength()
                               throws java.sql.SQLException

  Returns the maximum length of a column name.

  Specified by:
    `getMaxColumnNameLength` in interface `java.sql.DatabaseMetaData`
  Returns:
    8 if the SAS server is a V6 server else return 32 if its a V7 server.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### getMaxColumnsInGroupBy

    public int getMaxColumnsInGroupBy()
                               throws java.sql.SQLException

  Indicates the maximum number of columns that are allowed in a GROUP BY clause.

  Specified by:
    `getMaxColumnsInGroupBy` in interface `java.sql.DatabaseMetaData`
  Returns:
    0. There is no limit.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### getMaxColumnsInIndex

    public int getMaxColumnsInIndex()
                             throws java.sql.SQLException

  Indicates the maximum number of columns that are allowed in an index.

  Specified by:
    `getMaxColumnsInIndex` in interface `java.sql.DatabaseMetaData`
  Returns:
    0. There is no limit.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### getMaxColumnsInOrderBy

    public int getMaxColumnsInOrderBy()
                               throws java.sql.SQLException

  Indicates the maximum number of columns that are allowed in an ORDER BY clause.

  Specified by:
    `getMaxColumnsInOrderBy` in interface `java.sql.DatabaseMetaData`
  Returns:
    0. There is no limit.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### getMaxColumnsInSelect

    public int getMaxColumnsInSelect()
                              throws java.sql.SQLException

  Determines the maximum number of columns that are allowed in a SELECT list.

  Specified by:
    `getMaxColumnsInSelect` in interface `java.sql.DatabaseMetaData`
  Returns:
    0. There is no limit.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### getMaxColumnsInTable

    public int getMaxColumnsInTable()
                             throws java.sql.SQLException

  Indicates the maximum number of columns that are allowed in a table.

  Specified by:
    `getMaxColumnsInTable` in interface `java.sql.DatabaseMetaData`
  Returns:
    0. There is no limit.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### getMaxConnections

    public int getMaxConnections()
                          throws java.sql.SQLException

  Indicates the maximum number of database connections that can be active concurrently.

  Specified by:
    `getMaxConnections` in interface `java.sql.DatabaseMetaData`
  Returns:
    0. There is no limit.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### getMaxCursorNameLength

    public int getMaxCursorNameLength()
                               throws java.sql.SQLException

  Indicates the maximum length of a cursor name.

  Specified by:
    `getMaxCursorNameLength` in interface `java.sql.DatabaseMetaData`
  Returns:
    0. SAS software does not support cursors.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### getMaxIndexLength

    public int getMaxIndexLength()
                          throws java.sql.SQLException

  Indicates the maximum size of an index (in bytes).

  Specified by:
    `getMaxIndexLength` in interface `java.sql.DatabaseMetaData`
  Returns:
    0. There is no limit.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### getMaxSchemaNameLength

    public int getMaxSchemaNameLength()
                               throws java.sql.SQLException

  Indicates the maximum length of a schema name.

  Specified by:
    `getMaxSchemaNameLength` in interface `java.sql.DatabaseMetaData`
  Returns:
    8
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### getMaxProcedureNameLength

    public int getMaxProcedureNameLength()
                                  throws java.sql.SQLException

  Indicates the maximum length of a procedure name.

  Specified by:
    `getMaxProcedureNameLength` in interface `java.sql.DatabaseMetaData`
  Returns:
    0. SAS software does not support stored procedures.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### getMaxCatalogNameLength

    public int getMaxCatalogNameLength()
                                throws java.sql.SQLException

  Indicates the maximum length of a catalog name.

  Specified by:
    `getMaxCatalogNameLength` in interface `java.sql.DatabaseMetaData`
  Returns:
    0. SAS software does not support SQL catalogs.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### getMaxRowSize

    public int getMaxRowSize()
                      throws java.sql.SQLException

  Indicates the maximum length of a single row.

  Specified by:
    `getMaxRowSize` in interface `java.sql.DatabaseMetaData`
  Returns:
    0. There is no limit.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### doesMaxRowSizeIncludeBlobs

    public boolean doesMaxRowSizeIncludeBlobs()
                                       throws java.sql.SQLException

  Determines whether getMaxRowSize() includes LONGVARCHAR and LONGVARBINARY blobs.

  Specified by:
    `doesMaxRowSizeIncludeBlobs` in interface `java.sql.DatabaseMetaData`
  Returns:
    True.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### getMaxStatementLength

    public int getMaxStatementLength()
                              throws java.sql.SQLException

  Indicates the maximum length of an SQL statement.

  Specified by:
    `getMaxStatementLength` in interface `java.sql.DatabaseMetaData`
  Returns:
    0. There is no limit.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### getMaxStatements

    public int getMaxStatements()
                         throws java.sql.SQLException

  Indicates the maximum number of active statements that can be open to this database concurrently.

  Specified by:
    `getMaxStatements` in interface `java.sql.DatabaseMetaData`
  Returns:
    0. There is no limit.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### getMaxTableNameLength

    public int getMaxTableNameLength()
                              throws java.sql.SQLException

  Indicates the maximum length of a table name.

  Specified by:
    `getMaxTableNameLength` in interface `java.sql.DatabaseMetaData`
  Returns:
    8 if the SAS server is a V6 server else return 32 if its a V7 server.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### getMaxTablesInSelect

    public int getMaxTablesInSelect()
                             throws java.sql.SQLException

  Indicates the maximum number of tables in a SELECT list.

  Specified by:
    `getMaxTablesInSelect` in interface `java.sql.DatabaseMetaData`
  Returns:
    0. There is no limit.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### getMaxUserNameLength

    public int getMaxUserNameLength()
                             throws java.sql.SQLException

  Indicates the maximum length of a user name.

  Specified by:
    `getMaxUserNameLength` in interface `java.sql.DatabaseMetaData`
  Returns:
    8
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### getDefaultTransactionIsolation

    public int getDefaultTransactionIsolation()
                                       throws java.sql.SQLException

  Gets the default transaction isolation level for the database.

  Specified by:
    `getDefaultTransactionIsolation` in interface `java.sql.DatabaseMetaData`
  Returns:
    java.sql.Connection.TRANSACTION_NONE
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsTransactions

    public boolean supportsTransactions()
                                 throws java.sql.SQLException

  Determines whether transactions are supported.

  Specified by:
    `supportsTransactions` in interface `java.sql.DatabaseMetaData`
  Returns:
    False.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsTransactionIsolationLevel

    public boolean supportsTransactionIsolationLevel(int level)
                                              throws java.sql.SQLException

  Determines whether the database supports the transaction isolation level.

  Specified by:
    `supportsTransactionIsolationLevel` in interface `java.sql.DatabaseMetaData`
  Returns:
    True if the transaction isolation level is set to java.sql.Connection.TRANSACTION_NONE, else False.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsDataDefinitionAndDataManipulationTransactions

    public boolean supportsDataDefinitionAndDataManipulationTransactions()
                                                                  throws java.sql.SQLException

  Determines whether both data definition and data manipulation statements within a transaction are supported.

  Specified by:
    `supportsDataDefinitionAndDataManipulationTransactions` in interface `java.sql.DatabaseMetaData`
  Returns:
    False. SAS software does not support transactions.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### supportsDataManipulationTransactionsOnly

    public boolean supportsDataManipulationTransactionsOnly()
                                                     throws java.sql.SQLException

  Determines whether data manipulation statements within a transaction are supported.

  Specified by:
    `supportsDataManipulationTransactionsOnly` in interface `java.sql.DatabaseMetaData`
  Returns:
    False. SAS software does not support transactions.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### dataDefinitionCausesTransactionCommit

    public boolean dataDefinitionCausesTransactionCommit()
                                                  throws java.sql.SQLException

  Determines whether a data definition statement within a transaction forces the transaction to commit.

  Specified by:
    `dataDefinitionCausesTransactionCommit` in interface `java.sql.DatabaseMetaData`
  Returns:
    False. SAS software does not support transactions.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### dataDefinitionIgnoredInTransactions

    public boolean dataDefinitionIgnoredInTransactions()
                                                throws java.sql.SQLException

  Determines whether a data definition statement within a transaction is ignored.

  Specified by:
    `dataDefinitionIgnoredInTransactions` in interface `java.sql.DatabaseMetaData`
  Returns:
    False. SAS software does not support transactions.
  Throws:
    `java.sql.SQLException` - This exception is required by the interface, but it is never thrown.

### getProcedures

    public java.sql.ResultSet getProcedures(java.lang.String catalog,
                                            java.lang.String schemaPattern,
                                            java.lang.String procedureNamePattern)
                                     throws java.sql.SQLException

  Get a description of stored procedures available in a catalog. This method is not supported.

  Specified by:
    `getProcedures` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException` - This exception is always thrown.

### getProcedureColumns

    public java.sql.ResultSet getProcedureColumns(java.lang.String catalog,
                                                  java.lang.String schemaPattern,
                                                  java.lang.String procedureNamePattern,
                                                  java.lang.String columnNamePattern)
                                           throws java.sql.SQLException

  Gets a description of a catalog's stored procedure parameters and result columns. This method is not supported.

  Specified by:
    `getProcedureColumns` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException` - This exception is always thrown.

### getTables

    public java.sql.ResultSet getTables(java.lang.String catalog,
                                        java.lang.String schemaPattern,
                                        java.lang.String tableNamePattern,
                                        java.lang.String[] types)
                                 throws java.sql.SQLException

  Specified by:
    `getTables` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### getSchemas

    public java.sql.ResultSet getSchemas()
                                  throws java.sql.SQLException

  Specified by:
    `getSchemas` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### getCatalogs

    public java.sql.ResultSet getCatalogs()
                                   throws java.sql.SQLException

  Gets the catalog names that are available in this database. This method is not supported.

  Specified by:
    `getCatalogs` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException` - This exception is always thrown because SAS software does not support SQL catalogs.

### getTableTypes

    public java.sql.ResultSet getTableTypes()
                                     throws java.sql.SQLException

  Specified by:
    `getTableTypes` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### getColumns

    public java.sql.ResultSet getColumns(java.lang.String catalog,
                                         java.lang.String schemaPattern,
                                         java.lang.String tableNamePattern,
                                         java.lang.String columnNamePattern)
                                  throws java.sql.SQLException

  Specified by:
    `getColumns` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### getColumnPrivileges

    public java.sql.ResultSet getColumnPrivileges(java.lang.String catalog,
                                                  java.lang.String schema,
                                                  java.lang.String table,
                                                  java.lang.String columnNamePattern)
                                           throws java.sql.SQLException

  This method is not supported and will always throw a SQLException.

  Specified by:
    `getColumnPrivileges` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### getTablePrivileges

    public java.sql.ResultSet getTablePrivileges(java.lang.String catalog,
                                                 java.lang.String schemaPattern,
                                                 java.lang.String tableNamePattern)
                                          throws java.sql.SQLException

  This method is not supported and will always throw a SQLException.

  Specified by:
    `getTablePrivileges` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### getBestRowIdentifier

    public java.sql.ResultSet getBestRowIdentifier(java.lang.String catalog,
                                                   java.lang.String schema,
                                                   java.lang.String table,
                                                   int scope,
                                                   boolean nullable)
                                            throws java.sql.SQLException

  Specified by:
    `getBestRowIdentifier` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### getVersionColumns

    public java.sql.ResultSet getVersionColumns(java.lang.String catalog,
                                                java.lang.String schema,
                                                java.lang.String table)
                                         throws java.sql.SQLException

  This method is not supported and will always throw a SQLException.

  Specified by:
    `getVersionColumns` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### getPrimaryKeys

    public java.sql.ResultSet getPrimaryKeys(java.lang.String catalog,
                                             java.lang.String schema,
                                             java.lang.String table)
                                      throws java.sql.SQLException

  Specified by:
    `getPrimaryKeys` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### getImportedKeys

    public java.sql.ResultSet getImportedKeys(java.lang.String catalog,
                                              java.lang.String schema,
                                              java.lang.String table)
                                       throws java.sql.SQLException

  Specified by:
    `getImportedKeys` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### getExportedKeys

    public java.sql.ResultSet getExportedKeys(java.lang.String catalog,
                                              java.lang.String schema,
                                              java.lang.String table)
                                       throws java.sql.SQLException

  Specified by:
    `getExportedKeys` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### getCrossReference

    public java.sql.ResultSet getCrossReference(java.lang.String primaryCatalog,
                                                java.lang.String primarySchema,
                                                java.lang.String primaryTable,
                                                java.lang.String foreignCatalog,
                                                java.lang.String foreignSchema,
                                                java.lang.String foreignTable)
                                         throws java.sql.SQLException

  Specified by:
    `getCrossReference` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### getTypeInfo

    public java.sql.ResultSet getTypeInfo()
                                   throws java.sql.SQLException

  Specified by:
    `getTypeInfo` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### getIndexInfo

    public java.sql.ResultSet getIndexInfo(java.lang.String catalog,
                                           java.lang.String schema,
                                           java.lang.String table,
                                           boolean unique,
                                           boolean approximate)
                                    throws java.sql.SQLException

  Specified by:
    `getIndexInfo` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### supportsResultSetType

    public boolean supportsResultSetType(int type)
                                  throws java.sql.SQLException

  Specified by:
    `supportsResultSetType` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### supportsResultSetConcurrency

    public boolean supportsResultSetConcurrency(int type,
                                                int concurrency)
                                         throws java.sql.SQLException

  Specified by:
    `supportsResultSetConcurrency` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### ownUpdatesAreVisible

    public boolean ownUpdatesAreVisible(int type)
                                 throws java.sql.SQLException

  This method is not supported and will always throw a SQLException.

  Specified by:
    `ownUpdatesAreVisible` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### ownDeletesAreVisible

    public boolean ownDeletesAreVisible(int type)
                                 throws java.sql.SQLException

  This method is not supported and will always throw a SQLException.

  Specified by:
    `ownDeletesAreVisible` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### ownInsertsAreVisible

    public boolean ownInsertsAreVisible(int type)
                                 throws java.sql.SQLException

  This method is not supported and will always throw a SQLException.

  Specified by:
    `ownInsertsAreVisible` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### othersUpdatesAreVisible

    public boolean othersUpdatesAreVisible(int type)
                                    throws java.sql.SQLException

  This method is not supported and will always throw a SQLException.

  Specified by:
    `othersUpdatesAreVisible` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### othersDeletesAreVisible

    public boolean othersDeletesAreVisible(int type)
                                    throws java.sql.SQLException

  This method is not supported and will always throw a SQLException.

  Specified by:
    `othersDeletesAreVisible` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### othersInsertsAreVisible

    public boolean othersInsertsAreVisible(int type)
                                    throws java.sql.SQLException

  This method is not supported and will always throw a SQLException.

  Specified by:
    `othersInsertsAreVisible` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### updatesAreDetected

    public boolean updatesAreDetected(int type)
                               throws java.sql.SQLException

  This method is not supported and will always throw a SQLException.

  Specified by:
    `updatesAreDetected` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### deletesAreDetected

    public boolean deletesAreDetected(int type)
                               throws java.sql.SQLException

  This method is not supported and will always throw a SQLException.

  Specified by:
    `deletesAreDetected` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### insertsAreDetected

    public boolean insertsAreDetected(int type)
                               throws java.sql.SQLException

  This method is not supported and will always throw a SQLException.

  Specified by:
    `insertsAreDetected` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### supportsBatchUpdates

    public boolean supportsBatchUpdates()
                                 throws java.sql.SQLException

  Specified by:
    `supportsBatchUpdates` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### getUDTs

    public java.sql.ResultSet getUDTs(java.lang.String catalog,
                                      java.lang.String schemaPattern,
                                      java.lang.String typeNamePattern,
                                      int[] types)
                               throws java.sql.SQLException

  This method is not supported and will always throw a SQLException.

  Specified by:
    `getUDTs` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### getConnection

    public java.sql.Connection getConnection()
                                      throws java.sql.SQLException

  This method is not supported and will always throw a SQLException.

  Specified by:
    `getConnection` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### supportsSavepoints

    public boolean supportsSavepoints()
                               throws java.sql.SQLException

  This method is not supported and will always throw a SQLException.

  Specified by:
    `supportsSavepoints` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### supportsNamedParameters

    public boolean supportsNamedParameters()
                                    throws java.sql.SQLException

  This method is not supported and will always throw a SQLException.

  Specified by:
    `supportsNamedParameters` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### supportsMultipleOpenResults

    public boolean supportsMultipleOpenResults()
                                        throws java.sql.SQLException

  This method is not supported and will always throw a SQLException.

  Specified by:
    `supportsMultipleOpenResults` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### supportsGetGeneratedKeys

    public boolean supportsGetGeneratedKeys()
                                     throws java.sql.SQLException

  This method is not supported and will always throw a SQLException.

  Specified by:
    `supportsGetGeneratedKeys` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### getSuperTypes

    public java.sql.ResultSet getSuperTypes(java.lang.String catalog,
                                            java.lang.String schemaPattern,
                                            java.lang.String typeNamePattern)
                                     throws java.sql.SQLException

  This method is not supported and will always throw a SQLException.

  Specified by:
    `getSuperTypes` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### getSuperTables

    public java.sql.ResultSet getSuperTables(java.lang.String catalog,
                                             java.lang.String schemaPattern,
                                             java.lang.String tableNamePattern)
                                      throws java.sql.SQLException

  This method is not supported and will always throw a SQLException.

  Specified by:
    `getSuperTables` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### getAttributes

    public java.sql.ResultSet getAttributes(java.lang.String catalog,
                                            java.lang.String schemaPattern,
                                            java.lang.String typeNamePattern,
                                            java.lang.String attributeNamePattern)
                                     throws java.sql.SQLException

  This method is not supported and will always throw a SQLException.

  Specified by:
    `getAttributes` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### supportsResultSetHoldability

    public boolean supportsResultSetHoldability(int holdability)
                                         throws java.sql.SQLException

  This method is not supported and will always throw a SQLException.

  Specified by:
    `supportsResultSetHoldability` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### getResultSetHoldability

    public int getResultSetHoldability()
                                throws java.sql.SQLException

  This method is not supported and will always throw a SQLException.

  Specified by:
    `getResultSetHoldability` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### getDatabaseMajorVersion

    public int getDatabaseMajorVersion()
                                throws java.sql.SQLException

  Specified by:
    `getDatabaseMajorVersion` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### getDatabaseMinorVersion

    public int getDatabaseMinorVersion()
                                throws java.sql.SQLException

  Specified by:
    `getDatabaseMinorVersion` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### getJDBCMajorVersion

    public int getJDBCMajorVersion()
                            throws java.sql.SQLException

  This method is not supported and will always throw a SQLException.

  Specified by:
    `getJDBCMajorVersion` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### getJDBCMinorVersion

    public int getJDBCMinorVersion()
                            throws java.sql.SQLException

  This method is not supported and will always throw a SQLException.

  Specified by:
    `getJDBCMinorVersion` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### getSQLStateType

    public int getSQLStateType()
                        throws java.sql.SQLException

  This method is not supported and will always throw a SQLException.

  Specified by:
    `getSQLStateType` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### locatorsUpdateCopy

    public boolean locatorsUpdateCopy()
                               throws java.sql.SQLException

  This method is not supported and will always throw a SQLException.

  Specified by:
    `locatorsUpdateCopy` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### supportsStatementPooling

    public boolean supportsStatementPooling()
                                     throws java.sql.SQLException

  This method is not supported and will always throw a SQLException.

  Specified by:
    `supportsStatementPooling` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### getRowIdLifetime

    public java.sql.RowIdLifetime getRowIdLifetime()
                                            throws java.sql.SQLException

  This method is not supported and will always throw a SQLException.

  Specified by:
    `getRowIdLifetime` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### getSchemas

    public java.sql.ResultSet getSchemas(java.lang.String catalog,
                                         java.lang.String schemaPattern)
                                  throws java.sql.SQLException

  Specified by:
    `getSchemas` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### supportsStoredFunctionsUsingCallSyntax

    public boolean supportsStoredFunctionsUsingCallSyntax()
                                                   throws java.sql.SQLException

  This method is not supported and will always throw a SQLException.

  Specified by:
    `supportsStoredFunctionsUsingCallSyntax` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### autoCommitFailureClosesAllResultSets

    public boolean autoCommitFailureClosesAllResultSets()
                                                 throws java.sql.SQLException

  This method is not supported and will always throw a SQLException.

  Specified by:
    `autoCommitFailureClosesAllResultSets` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### getClientInfoProperties

    public java.sql.ResultSet getClientInfoProperties()
                                               throws java.sql.SQLException

  Specified by:
    `getClientInfoProperties` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### getFunctions

    public java.sql.ResultSet getFunctions(java.lang.String catalog,
                                           java.lang.String schemaPattern,
                                           java.lang.String functionNamePattern)
                                    throws java.sql.SQLException

  This method is not supported and will always throw a SQLException.

  Specified by:
    `getFunctions` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### getFunctionColumns

    public java.sql.ResultSet getFunctionColumns(java.lang.String catalog,
                                                 java.lang.String schemaPattern,
                                                 java.lang.String functionNamePattern,
                                                 java.lang.String columnNamePattern)
                                          throws java.sql.SQLException

  This method is not supported and will always throw a SQLException.

  Specified by:
    `getFunctionColumns` in interface `java.sql.DatabaseMetaData`
  Throws:
    `java.sql.SQLException`

### unwrap

    public <T> T unwrap(java.lang.Class<T> iface)
             throws java.sql.SQLException

  Specified by:
    `unwrap` in interface `java.sql.Wrapper`
  Throws:
    `java.sql.SQLException`

### isWrapperFor

    public boolean isWrapperFor(java.lang.Class<?> iface)
                         throws java.sql.SQLException

  Specified by:
    `isWrapperFor` in interface `java.sql.Wrapper`
  Throws:
    `java.sql.SQLException`

All Libraries | This Library | Package | Class | Use | Tree | Deprecated | Index | Grand Index | Help
|  | Components |
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2009 SAS Institute Inc. All Rights Reserved.