com.pivotal.gemfirexd.internal.client.am

## Class DatabaseMetaData

- java.lang.Object
- - com.pivotal.gemfirexd.internal.client.am.DatabaseMetaData

All Implemented Interfaces:
  DatabaseMetaData, Wrapper

Direct Known Subclasses:
  NetDatabaseMetaData

    public abstract class DatabaseMetaData
    extends Object
    implements DatabaseMetaData

### Field Summary

Fields
`protected Agent` `agent_`
`protected Connection` `connection_`
`static String` `DATATYPE`
`ProductLevel` `productLevel_`
`boolean` `useServerXAState_`

### Fields inherited from interface java.sql.DatabaseMetaData

`attributeNoNulls, attributeNullable, attributeNullableUnknown, bestRowNotPseudo, bestRowPseudo, bestRowSession, bestRowTemporary, bestRowTransaction, bestRowUnknown, columnNoNulls, columnNullable, columnNullableUnknown, functionColumnIn, functionColumnInOut, functionColumnOut, functionColumnResult, functionColumnUnknown, functionNoNulls, functionNoTable, functionNullable, functionNullableUnknown, functionResultUnknown, functionReturn, functionReturnsTable, importedKeyCascade, importedKeyInitiallyDeferred, importedKeyInitiallyImmediate, importedKeyNoAction, importedKeyNotDeferrable, importedKeyRestrict, importedKeySetDefault, importedKeySetNull, procedureColumnIn, procedureColumnInOut, procedureColumnOut, procedureColumnResult, procedureColumnReturn, procedureColumnUnknown, procedureNoNulls, procedureNoResult, procedureNullable, procedureNullableUnknown, procedureResultUnknown, procedureReturnsResult, sqlStateSQL, sqlStateSQL99, sqlStateXOpen, tableIndexClustered, tableIndexHashed, tableIndexOther, tableIndexStatistic, typeNoNulls, typeNullable, typeNullableUnknown, typePredBasic, typePredChar, typePredNone, typeSearchable, versionColumnNotPseudo, versionColumnPseudo, versionColumnUnknown`

### Constructor Summary

Constructors
`protected` `DatabaseMetaData(Agent agent, Connection connection, ProductLevel productLevel)`

### Method Summary

Methods
`boolean` `allProceduresAreCallable()`
`boolean` `allTablesAreSelectable()`
`boolean` `autoCommitFailureClosesAllResultSets()` Retrieves whether an `SQLException` will cause all open `ResultSet`s to be closed when auto-commit is `true`.
`protected void` `checkForClosedConnection()` A "public" version of checkForClosedConnection() that throws SQLException instead of SqlException.
`protected void` `checkServerJdbcVersionX(String method, int major, int minor)` Checks whether the server supports a JDBC version.
`protected abstract void` `computeFeatureSet_()`
`boolean` `dataDefinitionCausesTransactionCommit()`
`boolean` `dataDefinitionIgnoredInTransactions()`
`boolean` `deletesAreDetected(int type)`
`boolean` `doesMaxRowSizeIncludeBlobs()`
`ResultSet` `getAttributes(String catalog, String schemaPattern, String typeNamePattern, String attributeNamePattern)`
`ResultSet` `getBestRowIdentifier(String catalog, String schema, String table, int scope, boolean nullable)`
`ResultSet` `getCatalogs()`
`String` `getCatalogSeparator()`
`String` `getCatalogTerm()`
`ResultSet` `getClientInfoProperties()` Returns a list of the client info properties supported by the driver.
`ResultSet` `getColumnPrivileges(String catalog, String schema, String table, String columnNamePattern)`
`ResultSet` `getColumns(String catalog, String schemaPattern, String tableNamePattern, String columnNamePattern)`
`Connection` `getConnection()`
`ResultSet` `getCrossReference(String primaryCatalog, String primarySchema, String primaryTable, String foreignCatalog, String foreignSchema, String foreignTable)`
`int` `getDatabaseMajorVersion()`
`int` `getDatabaseMinorVersion()`
`String` `getDatabaseProductName()`
`String` `getDatabaseProductVersion()`
`int` `getDefaultTransactionIsolation()`
`int` `getDriverMajorVersion()`
`int` `getDriverMinorVersion()`
`String` `getDriverName()`
`String` `getDriverVersion()`
`ResultSet` `getExportedKeys(String catalog, String schema, String table)`
`String` `getExtraNameCharacters()`
`ResultSet` `getFunctionColumns(String catalog, String schemaPattern, String functionNamePattern, String parameterNamePattern)` Get the function names available in the database.
`ResultSet` `getFunctions(String catalog, String schemaPattern, String functionNamePattern)` Get the function names available in the database.
`String` `getIdentifierQuoteString()`
`ResultSet` `getImportedKeys(String catalog, String schema, String table)`
`ResultSet` `getIndexInfo(String catalog, String schema, String table, boolean unique, boolean approximate)`
`int` `getJDBCMajorVersion()`
`int` `getJDBCMinorVersion()`
`int` `getMaxBinaryLiteralLength()`
`int` `getMaxCatalogNameLength()`
`int` `getMaxCharLiteralLength()`
`int` `getMaxColumnNameLength()`
`int` `getMaxColumnsInGroupBy()`
`int` `getMaxColumnsInIndex()`
`int` `getMaxColumnsInOrderBy()`
`int` `getMaxColumnsInSelect()`
`int` `getMaxColumnsInTable()`
`int` `getMaxConnections()`
`int` `getMaxCursorNameLength()`
`int` `getMaxIndexLength()`
`int` `getMaxProcedureNameLength()`
`int` `getMaxRowSize()`
`int` `getMaxSchemaNameLength()`
`int` `getMaxStatementLength()`
`int` `getMaxStatements()`
`int` `getMaxTableNameLength()`
`int` `getMaxTablesInSelect()`
`int` `getMaxUserNameLength()`
`String` `getNumericFunctions()`
`ResultSet` `getPrimaryKeys(String catalog, String schema, String table)`
`ResultSet` `getProcedureColumns(String catalog, String schemaPattern, String procedureNamePattern, String columnNamePattern)`
`ResultSet` `getProcedures(String catalog, String schemaPattern, String procedureNamePattern)`
`String` `getProcedureTerm()`
`int` `getResultSetHoldability()`
`ResultSet` `getSchemas()`
`ResultSet` `getSchemas(String catalog, String schemaPattern)` Get the schema names available in this database.
`String` `getSchemaTerm()`
`String` `getSearchStringEscape()`
`String` `getSQLKeywords()`
`int` `getSQLStateType()`
`String` `getStringFunctions()`
`ResultSet` `getSuperTables(String catalog, String schemaPattern, String tableNamePattern)`
`ResultSet` `getSuperTypes(String catalog, String schemaPattern, String typeNamePattern)`
`String` `getSystemFunctions()`
`ResultSet` `getTablePrivileges(String catalog, String schemaPattern, String tableNamePattern)`
`ResultSet` `getTables(String catalog, String schemaPattern, String tableNamePattern, String[] types)`
`ResultSet` `getTableTypes()`
`String` `getTimeDateFunctions()`
`ResultSet` `getTypeInfo()`
`ResultSet` `getTypeInfo(short dataType)`
`ResultSet` `getUDTs(String catalog, String schemaPattern, String typeNamePattern, int[] types)`
`abstract String` `getURL_()`
`String` `getURL()`
`String` `getUserName()`
`ResultSet` `getVersionColumns(String catalog, String schema, String table)`
`boolean` `insertsAreDetected(int type)`
`boolean` `isCatalogAtStart()`
`boolean` `isReadOnly()`
`boolean` `locatorsUpdateCopy()`
`boolean` `nullPlusNonNullIsNull()`
`boolean` `nullsAreSortedAtEnd()`
`boolean` `nullsAreSortedAtStart()`
`boolean` `nullsAreSortedHigh()`
`boolean` `nullsAreSortedLow()`
`boolean` `othersDeletesAreVisible(int type)`
`boolean` `othersInsertsAreVisible(int type)`
`boolean` `othersUpdatesAreVisible(int type)`
`boolean` `ownDeletesAreVisible(int type)`
`boolean` `ownInsertsAreVisible(int type)`
`boolean` `ownUpdatesAreVisible(int type)`
`boolean` `storesLowerCaseIdentifiers()`
`boolean` `storesLowerCaseQuotedIdentifiers()`
`boolean` `storesMixedCaseIdentifiers()`
`boolean` `storesMixedCaseQuotedIdentifiers()`
`boolean` `storesUpperCaseIdentifiers()`
`boolean` `storesUpperCaseQuotedIdentifiers()`
`boolean` `supportsAlterTableWithAddColumn()`
`boolean` `supportsAlterTableWithDropColumn()`
`boolean` `supportsANSI92EntryLevelSQL()`
`boolean` `supportsANSI92FullSQL()`
`boolean` `supportsANSI92IntermediateSQL()`
`boolean` `supportsBatchUpdates()`
`boolean` `supportsCatalogsInDataManipulation()`
`boolean` `supportsCatalogsInIndexDefinitions()`
`boolean` `supportsCatalogsInPrivilegeDefinitions()`
`boolean` `supportsCatalogsInProcedureCalls()`
`boolean` `supportsCatalogsInTableDefinitions()`
`boolean` `supportsColumnAliasing()`
`boolean` `supportsConvert()`
`boolean` `supportsConvert(int fromType, int toType)`
`boolean` `supportsCoreSQLGrammar()`
`boolean` `supportsCorrelatedSubqueries()`
`boolean` `supportsDataDefinitionAndDataManipulationTransactions()`
`boolean` `supportsDataManipulationTransactionsOnly()`
`boolean` `supportsDifferentTableCorrelationNames()`
`boolean` `supportsExpressionsInOrderBy()`
`boolean` `supportsExtendedSQLGrammar()`
`boolean` `supportsFullOuterJoins()`
`boolean` `supportsGetGeneratedKeys()`
`boolean` `supportsGroupBy()`
`boolean` `supportsGroupByBeyondSelect()`
`boolean` `supportsGroupByUnrelated()`
`boolean` `supportsIntegrityEnhancementFacility()`
`boolean` `supportsLikeEscapeClause()`
`boolean` `supportsLimitedOuterJoins()`
`boolean` `supportsMinimumSQLGrammar()`
`boolean` `supportsMixedCaseIdentifiers()`
`boolean` `supportsMixedCaseQuotedIdentifiers()`
`boolean` `supportsMultipleOpenResults()`
`boolean` `supportsMultipleResultSets()`
`boolean` `supportsMultipleTransactions()`
`boolean` `supportsNamedParameters()`
`boolean` `supportsNonNullableColumns()`
`boolean` `supportsOpenCursorsAcrossCommit()`
`boolean` `supportsOpenCursorsAcrossRollback()`
`boolean` `supportsOpenStatementsAcrossCommit()`
`boolean` `supportsOpenStatementsAcrossRollback()`
`boolean` `supportsOrderByUnrelated()`
`boolean` `supportsOuterJoins()`
`boolean` `supportsPositionedDelete()`
`boolean` `supportsPositionedUpdate()`
`boolean` `supportsResultSetConcurrency(int type, int concurrency)`
`boolean` `supportsResultSetHoldability(int holdability)`
`boolean` `supportsResultSetType(int type)`
`boolean` `supportsSavepoints()`
`boolean` `supportsSchemasInDataManipulation()`
`boolean` `supportsSchemasInIndexDefinitions()`
`boolean` `supportsSchemasInPrivilegeDefinitions()`
`boolean` `supportsSchemasInProcedureCalls()`
`boolean` `supportsSchemasInTableDefinitions()`
`boolean` `supportsSelectForUpdate()`
`boolean` `supportsStatementPooling()`
`boolean` `supportsStoredFunctionsUsingCallSyntax()` Retrieves whether this database supports invoking user-defined or vendor functions using the stored procedure escape syntax.
`boolean` `supportsStoredProcedures()`
`boolean` `supportsSubqueriesInComparisons()`
`boolean` `supportsSubqueriesInExists()`
`boolean` `supportsSubqueriesInIns()`
`boolean` `supportsSubqueriesInQuantifieds()`
`boolean` `supportsTableCorrelationNames()`
`boolean` `supportsTransactionIsolationLevel(int level)`
`boolean` `supportsTransactions()`
`boolean` `supportsUnion()`
`boolean` `supportsUnionAll()`
`boolean` `updatesAreDetected(int type)`
`boolean` `usesLocalFilePerTable()`
`boolean` `usesLocalFiles()`

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Methods inherited from interface java.sql.DatabaseMetaData

`generatedKeyAlwaysReturned, getPseudoColumns, getRowIdLifetime`

### Methods inherited from interface java.sql.Wrapper

`isWrapperFor, unwrap`

### Field Detail

#### agent_

    protected Agent agent_

#### connection_

    protected Connection connection_

#### productLevel_

    public ProductLevel productLevel_

#### useServerXAState_

    public boolean useServerXAState_

#### DATATYPE

    public static final String DATATYPE

### Constructor Detail

#### DatabaseMetaData

    protected DatabaseMetaData(Agent agent,
                    Connection connection,
                    ProductLevel productLevel)

### Method Detail

#### allProceduresAreCallable

    public boolean allProceduresAreCallable()
                                     throws SQLException

Specified by:
  `allProceduresAreCallable` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### allTablesAreSelectable

    public boolean allTablesAreSelectable()
                                   throws SQLException

Specified by:
  `allTablesAreSelectable` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### nullsAreSortedHigh

    public boolean nullsAreSortedHigh()
                               throws SQLException

Specified by:
  `nullsAreSortedHigh` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### nullsAreSortedLow

    public boolean nullsAreSortedLow()
                              throws SQLException

Specified by:
  `nullsAreSortedLow` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### nullsAreSortedAtStart

    public boolean nullsAreSortedAtStart()
                                  throws SQLException

Specified by:
  `nullsAreSortedAtStart` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### nullsAreSortedAtEnd

    public boolean nullsAreSortedAtEnd()
                                throws SQLException

Specified by:
  `nullsAreSortedAtEnd` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### usesLocalFiles

    public boolean usesLocalFiles()
                           throws SQLException

Specified by:
  `usesLocalFiles` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### usesLocalFilePerTable

    public boolean usesLocalFilePerTable()
                                  throws SQLException

Specified by:
  `usesLocalFilePerTable` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### storesUpperCaseIdentifiers

    public boolean storesUpperCaseIdentifiers()
                                       throws SQLException

Specified by:
  `storesUpperCaseIdentifiers` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### storesLowerCaseIdentifiers

    public boolean storesLowerCaseIdentifiers()
                                       throws SQLException

Specified by:
  `storesLowerCaseIdentifiers` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### storesMixedCaseIdentifiers

    public boolean storesMixedCaseIdentifiers()
                                       throws SQLException

Specified by:
  `storesMixedCaseIdentifiers` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### storesUpperCaseQuotedIdentifiers

    public boolean storesUpperCaseQuotedIdentifiers()
                                             throws SQLException

Specified by:
  `storesUpperCaseQuotedIdentifiers` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### storesLowerCaseQuotedIdentifiers

    public boolean storesLowerCaseQuotedIdentifiers()
                                             throws SQLException

Specified by:
  `storesLowerCaseQuotedIdentifiers` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### storesMixedCaseQuotedIdentifiers

    public boolean storesMixedCaseQuotedIdentifiers()
                                             throws SQLException

Specified by:
  `storesMixedCaseQuotedIdentifiers` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getSQLKeywords

    public String getSQLKeywords()
                          throws SQLException

Specified by:
  `getSQLKeywords` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getNumericFunctions

    public String getNumericFunctions()
                               throws SQLException

Specified by:
  `getNumericFunctions` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getStringFunctions

    public String getStringFunctions()
                              throws SQLException

Specified by:
  `getStringFunctions` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getSystemFunctions

    public String getSystemFunctions()
                              throws SQLException

Specified by:
  `getSystemFunctions` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getTimeDateFunctions

    public String getTimeDateFunctions()
                                throws SQLException

Specified by:
  `getTimeDateFunctions` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getSearchStringEscape

    public String getSearchStringEscape()
                                 throws SQLException

Specified by:
  `getSearchStringEscape` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getExtraNameCharacters

    public String getExtraNameCharacters()
                                  throws SQLException

Specified by:
  `getExtraNameCharacters` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsAlterTableWithAddColumn

    public boolean supportsAlterTableWithAddColumn()
                                            throws SQLException

Specified by:
  `supportsAlterTableWithAddColumn` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsAlterTableWithDropColumn

    public boolean supportsAlterTableWithDropColumn()
                                             throws SQLException

Specified by:
  `supportsAlterTableWithDropColumn` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsConvert

    public boolean supportsConvert()
                            throws SQLException

Specified by:
  `supportsConvert` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsConvert

    public boolean supportsConvert(int fromType,
                          int toType)
                            throws SQLException

Specified by:
  `supportsConvert` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsDifferentTableCorrelationNames

    public boolean supportsDifferentTableCorrelationNames()
                                                   throws SQLException

Specified by:
  `supportsDifferentTableCorrelationNames` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsExpressionsInOrderBy

    public boolean supportsExpressionsInOrderBy()
                                         throws SQLException

Specified by:
  `supportsExpressionsInOrderBy` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsOrderByUnrelated

    public boolean supportsOrderByUnrelated()
                                     throws SQLException

Specified by:
  `supportsOrderByUnrelated` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsGroupBy

    public boolean supportsGroupBy()
                            throws SQLException

Specified by:
  `supportsGroupBy` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsGroupByUnrelated

    public boolean supportsGroupByUnrelated()
                                     throws SQLException

Specified by:
  `supportsGroupByUnrelated` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsGroupByBeyondSelect

    public boolean supportsGroupByBeyondSelect()
                                        throws SQLException

Specified by:
  `supportsGroupByBeyondSelect` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsMultipleResultSets

    public boolean supportsMultipleResultSets()
                                       throws SQLException

Specified by:
  `supportsMultipleResultSets` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsMultipleTransactions

    public boolean supportsMultipleTransactions()
                                         throws SQLException

Specified by:
  `supportsMultipleTransactions` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsCoreSQLGrammar

    public boolean supportsCoreSQLGrammar()
                                   throws SQLException

Specified by:
  `supportsCoreSQLGrammar` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsExtendedSQLGrammar

    public boolean supportsExtendedSQLGrammar()
                                       throws SQLException

Specified by:
  `supportsExtendedSQLGrammar` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsANSI92IntermediateSQL

    public boolean supportsANSI92IntermediateSQL()
                                          throws SQLException

Specified by:
  `supportsANSI92IntermediateSQL` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsANSI92FullSQL

    public boolean supportsANSI92FullSQL()
                                  throws SQLException

Specified by:
  `supportsANSI92FullSQL` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsIntegrityEnhancementFacility

    public boolean supportsIntegrityEnhancementFacility()
                                                 throws SQLException

Specified by:
  `supportsIntegrityEnhancementFacility` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsOuterJoins

    public boolean supportsOuterJoins()
                               throws SQLException

Specified by:
  `supportsOuterJoins` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsFullOuterJoins

    public boolean supportsFullOuterJoins()
                                   throws SQLException

Specified by:
  `supportsFullOuterJoins` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsLimitedOuterJoins

    public boolean supportsLimitedOuterJoins()
                                      throws SQLException

Specified by:
  `supportsLimitedOuterJoins` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getSchemaTerm

    public String getSchemaTerm()
                         throws SQLException

Specified by:
  `getSchemaTerm` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getProcedureTerm

    public String getProcedureTerm()
                            throws SQLException

Specified by:
  `getProcedureTerm` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getCatalogTerm

    public String getCatalogTerm()
                          throws SQLException

Specified by:
  `getCatalogTerm` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### isCatalogAtStart

    public boolean isCatalogAtStart()
                             throws SQLException

Specified by:
  `isCatalogAtStart` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getCatalogSeparator

    public String getCatalogSeparator()
                               throws SQLException

Specified by:
  `getCatalogSeparator` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsSchemasInDataManipulation

    public boolean supportsSchemasInDataManipulation()
                                              throws SQLException

Specified by:
  `supportsSchemasInDataManipulation` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsSchemasInProcedureCalls

    public boolean supportsSchemasInProcedureCalls()
                                            throws SQLException

Specified by:
  `supportsSchemasInProcedureCalls` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsSchemasInTableDefinitions

    public boolean supportsSchemasInTableDefinitions()
                                              throws SQLException

Specified by:
  `supportsSchemasInTableDefinitions` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsSchemasInIndexDefinitions

    public boolean supportsSchemasInIndexDefinitions()
                                              throws SQLException

Specified by:
  `supportsSchemasInIndexDefinitions` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsSchemasInPrivilegeDefinitions

    public boolean supportsSchemasInPrivilegeDefinitions()
                                                  throws SQLException

Specified by:
  `supportsSchemasInPrivilegeDefinitions` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsCatalogsInDataManipulation

    public boolean supportsCatalogsInDataManipulation()
                                               throws SQLException

Specified by:
  `supportsCatalogsInDataManipulation` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsCatalogsInProcedureCalls

    public boolean supportsCatalogsInProcedureCalls()
                                             throws SQLException

Specified by:
  `supportsCatalogsInProcedureCalls` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsCatalogsInTableDefinitions

    public boolean supportsCatalogsInTableDefinitions()
                                               throws SQLException

Specified by:
  `supportsCatalogsInTableDefinitions` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsCatalogsInIndexDefinitions

    public boolean supportsCatalogsInIndexDefinitions()
                                               throws SQLException

Specified by:
  `supportsCatalogsInIndexDefinitions` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsCatalogsInPrivilegeDefinitions

    public boolean supportsCatalogsInPrivilegeDefinitions()
                                                   throws SQLException

Specified by:
  `supportsCatalogsInPrivilegeDefinitions` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsPositionedDelete

    public boolean supportsPositionedDelete()
                                     throws SQLException

Specified by:
  `supportsPositionedDelete` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsPositionedUpdate

    public boolean supportsPositionedUpdate()
                                     throws SQLException

Specified by:
  `supportsPositionedUpdate` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsSelectForUpdate

    public boolean supportsSelectForUpdate()
                                    throws SQLException

Specified by:
  `supportsSelectForUpdate` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsStoredProcedures

    public boolean supportsStoredProcedures()
                                     throws SQLException

Specified by:
  `supportsStoredProcedures` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsSubqueriesInComparisons

    public boolean supportsSubqueriesInComparisons()
                                            throws SQLException

Specified by:
  `supportsSubqueriesInComparisons` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsUnion

    public boolean supportsUnion()
                          throws SQLException

Specified by:
  `supportsUnion` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsUnionAll

    public boolean supportsUnionAll()
                             throws SQLException

Specified by:
  `supportsUnionAll` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsOpenCursorsAcrossCommit

    public boolean supportsOpenCursorsAcrossCommit()
                                            throws SQLException

Specified by:
  `supportsOpenCursorsAcrossCommit` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsOpenCursorsAcrossRollback

    public boolean supportsOpenCursorsAcrossRollback()
                                              throws SQLException

Specified by:
  `supportsOpenCursorsAcrossRollback` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsOpenStatementsAcrossCommit

    public boolean supportsOpenStatementsAcrossCommit()
                                               throws SQLException

Specified by:
  `supportsOpenStatementsAcrossCommit` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsOpenStatementsAcrossRollback

    public boolean supportsOpenStatementsAcrossRollback()
                                                 throws SQLException

Specified by:
  `supportsOpenStatementsAcrossRollback` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getMaxBinaryLiteralLength

    public int getMaxBinaryLiteralLength()
                                  throws SQLException

Specified by:
  `getMaxBinaryLiteralLength` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getMaxCharLiteralLength

    public int getMaxCharLiteralLength()
                                throws SQLException

Specified by:
  `getMaxCharLiteralLength` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getMaxColumnNameLength

    public int getMaxColumnNameLength()
                               throws SQLException

Specified by:
  `getMaxColumnNameLength` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getMaxColumnsInGroupBy

    public int getMaxColumnsInGroupBy()
                               throws SQLException

Specified by:
  `getMaxColumnsInGroupBy` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getMaxColumnsInIndex

    public int getMaxColumnsInIndex()
                             throws SQLException

Specified by:
  `getMaxColumnsInIndex` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getMaxColumnsInOrderBy

    public int getMaxColumnsInOrderBy()
                               throws SQLException

Specified by:
  `getMaxColumnsInOrderBy` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getMaxColumnsInSelect

    public int getMaxColumnsInSelect()
                              throws SQLException

Specified by:
  `getMaxColumnsInSelect` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getMaxColumnsInTable

    public int getMaxColumnsInTable()
                             throws SQLException

Specified by:
  `getMaxColumnsInTable` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getMaxConnections

    public int getMaxConnections()
                          throws SQLException

Specified by:
  `getMaxConnections` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getMaxCursorNameLength

    public int getMaxCursorNameLength()
                               throws SQLException

Specified by:
  `getMaxCursorNameLength` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getMaxIndexLength

    public int getMaxIndexLength()
                          throws SQLException

Specified by:
  `getMaxIndexLength` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getMaxSchemaNameLength

    public int getMaxSchemaNameLength()
                               throws SQLException

Specified by:
  `getMaxSchemaNameLength` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getMaxProcedureNameLength

    public int getMaxProcedureNameLength()
                                  throws SQLException

Specified by:
  `getMaxProcedureNameLength` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getMaxCatalogNameLength

    public int getMaxCatalogNameLength()
                                throws SQLException

Specified by:
  `getMaxCatalogNameLength` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getMaxRowSize

    public int getMaxRowSize()
                      throws SQLException

Specified by:
  `getMaxRowSize` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### doesMaxRowSizeIncludeBlobs

    public boolean doesMaxRowSizeIncludeBlobs()
                                       throws SQLException

Specified by:
  `doesMaxRowSizeIncludeBlobs` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getMaxStatementLength

    public int getMaxStatementLength()
                              throws SQLException

Specified by:
  `getMaxStatementLength` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getMaxStatements

    public int getMaxStatements()
                         throws SQLException

Specified by:
  `getMaxStatements` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getMaxTableNameLength

    public int getMaxTableNameLength()
                              throws SQLException

Specified by:
  `getMaxTableNameLength` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getMaxTablesInSelect

    public int getMaxTablesInSelect()
                             throws SQLException

Specified by:
  `getMaxTablesInSelect` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getMaxUserNameLength

    public int getMaxUserNameLength()
                             throws SQLException

Specified by:
  `getMaxUserNameLength` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getDefaultTransactionIsolation

    public int getDefaultTransactionIsolation()
                                       throws SQLException

Specified by:
  `getDefaultTransactionIsolation` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsTransactions

    public boolean supportsTransactions()
                                 throws SQLException

Specified by:
  `supportsTransactions` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsTransactionIsolationLevel

    public boolean supportsTransactionIsolationLevel(int level)
                                              throws SQLException

Specified by:
  `supportsTransactionIsolationLevel` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsDataDefinitionAndDataManipulationTransactions

    public boolean supportsDataDefinitionAndDataManipulationTransactions()
                                                                  throws SQLException

Specified by:
  `supportsDataDefinitionAndDataManipulationTransactions` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsDataManipulationTransactionsOnly

    public boolean supportsDataManipulationTransactionsOnly()
                                                     throws SQLException

Specified by:
  `supportsDataManipulationTransactionsOnly` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### dataDefinitionCausesTransactionCommit

    public boolean dataDefinitionCausesTransactionCommit()
                                                  throws SQLException

Specified by:
  `dataDefinitionCausesTransactionCommit` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### dataDefinitionIgnoredInTransactions

    public boolean dataDefinitionIgnoredInTransactions()
                                                throws SQLException

Specified by:
  `dataDefinitionIgnoredInTransactions` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsResultSetType

    public boolean supportsResultSetType(int type)
                                  throws SQLException

Specified by:
  `supportsResultSetType` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsResultSetConcurrency

    public boolean supportsResultSetConcurrency(int type,
                                       int concurrency)
                                         throws SQLException

Specified by:
  `supportsResultSetConcurrency` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### ownUpdatesAreVisible

    public boolean ownUpdatesAreVisible(int type)
                                 throws SQLException

Specified by:
  `ownUpdatesAreVisible` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### ownDeletesAreVisible

    public boolean ownDeletesAreVisible(int type)
                                 throws SQLException

Specified by:
  `ownDeletesAreVisible` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### ownInsertsAreVisible

    public boolean ownInsertsAreVisible(int type)
                                 throws SQLException

Specified by:
  `ownInsertsAreVisible` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### othersUpdatesAreVisible

    public boolean othersUpdatesAreVisible(int type)
                                    throws SQLException

Specified by:
  `othersUpdatesAreVisible` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### othersDeletesAreVisible

    public boolean othersDeletesAreVisible(int type)
                                    throws SQLException

Specified by:
  `othersDeletesAreVisible` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### othersInsertsAreVisible

    public boolean othersInsertsAreVisible(int type)
                                    throws SQLException

Specified by:
  `othersInsertsAreVisible` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### updatesAreDetected

    public boolean updatesAreDetected(int type)
                               throws SQLException

Specified by:
  `updatesAreDetected` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### deletesAreDetected

    public boolean deletesAreDetected(int type)
                               throws SQLException

Specified by:
  `deletesAreDetected` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### insertsAreDetected

    public boolean insertsAreDetected(int type)
                               throws SQLException

Specified by:
  `insertsAreDetected` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsBatchUpdates

    public boolean supportsBatchUpdates()
                                 throws SQLException

Specified by:
  `supportsBatchUpdates` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsSavepoints

    public boolean supportsSavepoints()
                               throws SQLException

Specified by:
  `supportsSavepoints` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getURL_

    public abstract String getURL_()
                            throws SqlException

Throws:
  `SqlException`

#### getURL

    public String getURL()
                  throws SQLException

Specified by:
  `getURL` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getUserName

    public String getUserName()
                       throws SQLException

Specified by:
  `getUserName` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### isReadOnly

    public boolean isReadOnly()
                       throws SQLException

Specified by:
  `isReadOnly` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getDatabaseProductName

    public String getDatabaseProductName()
                                  throws SQLException

Specified by:
  `getDatabaseProductName` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getDatabaseProductVersion

    public String getDatabaseProductVersion()
                                     throws SQLException

Specified by:
  `getDatabaseProductVersion` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getDriverName

    public String getDriverName()
                         throws SQLException

Specified by:
  `getDriverName` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getDriverVersion

    public String getDriverVersion()
                            throws SQLException

Specified by:
  `getDriverVersion` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getDriverMajorVersion

    public int getDriverMajorVersion()

Specified by:
  `getDriverMajorVersion` in interface `DatabaseMetaData`

#### getDriverMinorVersion

    public int getDriverMinorVersion()

Specified by:
  `getDriverMinorVersion` in interface `DatabaseMetaData`

#### supportsMixedCaseIdentifiers

    public boolean supportsMixedCaseIdentifiers()
                                         throws SQLException

Specified by:
  `supportsMixedCaseIdentifiers` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsMixedCaseQuotedIdentifiers

    public boolean supportsMixedCaseQuotedIdentifiers()
                                               throws SQLException

Specified by:
  `supportsMixedCaseQuotedIdentifiers` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getIdentifierQuoteString

    public String getIdentifierQuoteString()
                                    throws SQLException

Specified by:
  `getIdentifierQuoteString` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsColumnAliasing

    public boolean supportsColumnAliasing()
                                   throws SQLException

Specified by:
  `supportsColumnAliasing` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### nullPlusNonNullIsNull

    public boolean nullPlusNonNullIsNull()
                                  throws SQLException

Specified by:
  `nullPlusNonNullIsNull` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsTableCorrelationNames

    public boolean supportsTableCorrelationNames()
                                          throws SQLException

Specified by:
  `supportsTableCorrelationNames` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsLikeEscapeClause

    public boolean supportsLikeEscapeClause()
                                     throws SQLException

Specified by:
  `supportsLikeEscapeClause` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsNonNullableColumns

    public boolean supportsNonNullableColumns()
                                       throws SQLException

Specified by:
  `supportsNonNullableColumns` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsMinimumSQLGrammar

    public boolean supportsMinimumSQLGrammar()
                                      throws SQLException

Specified by:
  `supportsMinimumSQLGrammar` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsANSI92EntryLevelSQL

    public boolean supportsANSI92EntryLevelSQL()
                                        throws SQLException

Specified by:
  `supportsANSI92EntryLevelSQL` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsSubqueriesInExists

    public boolean supportsSubqueriesInExists()
                                       throws SQLException

Specified by:
  `supportsSubqueriesInExists` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsSubqueriesInIns

    public boolean supportsSubqueriesInIns()
                                    throws SQLException

Specified by:
  `supportsSubqueriesInIns` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsSubqueriesInQuantifieds

    public boolean supportsSubqueriesInQuantifieds()
                                            throws SQLException

Specified by:
  `supportsSubqueriesInQuantifieds` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsCorrelatedSubqueries

    public boolean supportsCorrelatedSubqueries()
                                         throws SQLException

Specified by:
  `supportsCorrelatedSubqueries` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getProcedures

    public ResultSet getProcedures(String catalog,
                          String schemaPattern,
                          String procedureNamePattern)
                            throws SQLException

Specified by:
  `getProcedures` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getProcedureColumns

    public ResultSet getProcedureColumns(String catalog,
                                String schemaPattern,
                                String procedureNamePattern,
                                String columnNamePattern)
                                  throws SQLException

Specified by:
  `getProcedureColumns` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getFunctions

    public ResultSet getFunctions(String catalog,
                         String schemaPattern,
                         String functionNamePattern)
                           throws SQLException

Get the function names available in the database. Calls stored procedure `SYSIBM.SQLFunctions(CatalogName varchar(128), SchemaName varchar(128), FuncName varchar(128), Options varchar(4000))` on the server. This procedure will in turn call `EmbedDatabaseMetaData.getFunctions(String,String,String)`

Compatibility: Only available if both server and client version > 10.1, and JDK version >= 1.6. Older clients will not have this method available. Newer clients will be able to call this method when connected to an older server, but this will be trigger an exception in `checkServerJdbcVersionX()`.

Upgrade: `SYSIBM.SQLFunctions` is added in `DataDictionaryImpl.create_10_2_system_procedures (TransactionController,UUID)` so it will become available in newly created databases and after hard upgrade.

Specified by:
  `getFunctions` in interface `DatabaseMetaData`
Parameters:
  `catalog` - limit search to this catalog
  `schemaPattern` - limit search to schemas matching this pattern
  `functionNamePattern` - limit search to functions matching this pattern
Returns:
  a `ResultSet` listing the fucntions
Throws:
  `SqlException` - if a database error occurs
  `SQLException`
See Also:
  `getFunctionsX(String, String, String)`, `com.pivotal.gemfirexd.internal.impl.sql.catalog.DataDictionaryImpl#create_10_2_system_procedures(TransactionController,HashSet, UUID)`, `com.pivotal.gemfirexd.internal.impl.jdbc.EmbedDatabaseMetaData#getFunctions(String,String,String)`

#### getFunctionColumns

    public ResultSet getFunctionColumns(String catalog,
                               String schemaPattern,
                               String functionNamePattern,
                               String parameterNamePattern)
                                 throws SQLException

Get the function names available in the database. Calls stored procedure `SYSIBM.SQLFunctionParams(CatalogName varchar(128), SchemaName varchar(128), FuncName varchar(128), ParamName varchar(128), Options varchar(4000))` on the server. This procedure will in turn call `EmbedDatabaseMetaData.getFunctionColumns(String,String, String,String)`

Compatibility: Only available if both server and client version > 10.1, and JDK version >= 1.6. Older clients will not have this method available. Newer clients will be able to call this method when connected to an older server, but this will be trigger an exception in `checkServerJdbcVersionX()`.

Upgrade: `SYSIBM.SQLFunctionParams` is added in `DataDictionaryImpl.create_10_2_system_procedures (TransactionController,UUID)` so it will become available in newly created databases and after hard upgrade.

Specified by:
  `getFunctionColumns` in interface `DatabaseMetaData`
Parameters:
  `catalog` - limit search to this catalog
  `schemaPattern` - limit search to schemas matching this pattern
  `functionNamePattern` - limit search to functions matching this pattern
Returns:
  a `ResultSet` listing the fucntions
Throws:
  `SqlException` - if a database error occurs
  `SQLException`
See Also:
  `getFunctionColumnsX(String, String, String,String)`, `com.pivotal.gemfirexd.internal.impl.sql.catalog.DataDictionaryImpl#create_10_2_system_procedures(TransactionController,HashSet, UUID)`, `com.pivotal.gemfirexd.internal.impl.jdbc.EmbedDatabaseMetaData#getFunctions(String,String,String)`

#### getTables

    public ResultSet getTables(String catalog,
                      String schemaPattern,
                      String tableNamePattern,
                      String[] types)
                        throws SQLException

Specified by:
  `getTables` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getSchemas

    public ResultSet getSchemas()
                         throws SQLException

Specified by:
  `getSchemas` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getCatalogs

    public ResultSet getCatalogs()
                          throws SQLException

Specified by:
  `getCatalogs` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getTableTypes

    public ResultSet getTableTypes()
                            throws SQLException

Specified by:
  `getTableTypes` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getColumns

    public ResultSet getColumns(String catalog,
                       String schemaPattern,
                       String tableNamePattern,
                       String columnNamePattern)
                         throws SQLException

Specified by:
  `getColumns` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getColumnPrivileges

    public ResultSet getColumnPrivileges(String catalog,
                                String schema,
                                String table,
                                String columnNamePattern)
                                  throws SQLException

Specified by:
  `getColumnPrivileges` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getTablePrivileges

    public ResultSet getTablePrivileges(String catalog,
                               String schemaPattern,
                               String tableNamePattern)
                                 throws SQLException

Specified by:
  `getTablePrivileges` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getBestRowIdentifier

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

Specified by:
  `getBestRowIdentifier` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getVersionColumns

    public ResultSet getVersionColumns(String catalog,
                              String schema,
                              String table)
                                throws SQLException

Specified by:
  `getVersionColumns` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getPrimaryKeys

    public ResultSet getPrimaryKeys(String catalog,
                           String schema,
                           String table)
                             throws SQLException

Specified by:
  `getPrimaryKeys` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getImportedKeys

    public ResultSet getImportedKeys(String catalog,
                            String schema,
                            String table)
                              throws SQLException

Specified by:
  `getImportedKeys` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getExportedKeys

    public ResultSet getExportedKeys(String catalog,
                            String schema,
                            String table)
                              throws SQLException

Specified by:
  `getExportedKeys` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getCrossReference

    public ResultSet getCrossReference(String primaryCatalog,
                              String primarySchema,
                              String primaryTable,
                              String foreignCatalog,
                              String foreignSchema,
                              String foreignTable)
                                throws SQLException

Specified by:
  `getCrossReference` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getTypeInfo

    public ResultSet getTypeInfo()
                          throws SQLException

Specified by:
  `getTypeInfo` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getTypeInfo

    public ResultSet getTypeInfo(short dataType)
                          throws SQLException

Throws:
  `SQLException`

#### getIndexInfo

    public ResultSet getIndexInfo(String catalog,
                         String schema,
                         String table,
                         boolean unique,
                         boolean approximate)
                           throws SQLException

Specified by:
  `getIndexInfo` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getUDTs

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

Specified by:
  `getUDTs` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getConnection

    public Connection getConnection()
                             throws SQLException

Specified by:
  `getConnection` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsNamedParameters

    public boolean supportsNamedParameters()
                                    throws SQLException

Specified by:
  `supportsNamedParameters` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsMultipleOpenResults

    public boolean supportsMultipleOpenResults()
                                        throws SQLException

Specified by:
  `supportsMultipleOpenResults` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsGetGeneratedKeys

    public boolean supportsGetGeneratedKeys()
                                     throws SQLException

Specified by:
  `supportsGetGeneratedKeys` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getSuperTypes

    public ResultSet getSuperTypes(String catalog,
                          String schemaPattern,
                          String typeNamePattern)
                            throws SQLException

Specified by:
  `getSuperTypes` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getSuperTables

    public ResultSet getSuperTables(String catalog,
                           String schemaPattern,
                           String tableNamePattern)
                             throws SQLException

Specified by:
  `getSuperTables` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getAttributes

    public ResultSet getAttributes(String catalog,
                          String schemaPattern,
                          String typeNamePattern,
                          String attributeNamePattern)
                            throws SQLException

Specified by:
  `getAttributes` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsResultSetHoldability

    public boolean supportsResultSetHoldability(int holdability)
                                         throws SQLException

Specified by:
  `supportsResultSetHoldability` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getResultSetHoldability

    public int getResultSetHoldability()
                                throws SQLException

Specified by:
  `getResultSetHoldability` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getDatabaseMajorVersion

    public int getDatabaseMajorVersion()
                                throws SQLException

Specified by:
  `getDatabaseMajorVersion` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getDatabaseMinorVersion

    public int getDatabaseMinorVersion()
                                throws SQLException

Specified by:
  `getDatabaseMinorVersion` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getJDBCMajorVersion

    public int getJDBCMajorVersion()
                            throws SQLException

Specified by:
  `getJDBCMajorVersion` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getJDBCMinorVersion

    public int getJDBCMinorVersion()
                            throws SQLException

Specified by:
  `getJDBCMinorVersion` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### getSQLStateType

    public int getSQLStateType()
                        throws SQLException

Specified by:
  `getSQLStateType` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### locatorsUpdateCopy

    public boolean locatorsUpdateCopy()
                               throws SQLException

Specified by:
  `locatorsUpdateCopy` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### supportsStatementPooling

    public boolean supportsStatementPooling()
                                     throws SQLException

Specified by:
  `supportsStatementPooling` in interface `DatabaseMetaData`
Throws:
  `SQLException`

#### computeFeatureSet_

    protected abstract void computeFeatureSet_()

#### supportsStoredFunctionsUsingCallSyntax

    public final boolean supportsStoredFunctionsUsingCallSyntax()
                                                         throws SQLException

Retrieves whether this database supports invoking user-defined or vendor functions using the stored procedure escape syntax.

Specified by:
  `supportsStoredFunctionsUsingCallSyntax` in interface `DatabaseMetaData`
Returns:
  `true`, since Derby supports the escape syntax
Throws:
  `SQLException` - if a database access error occurs

#### autoCommitFailureClosesAllResultSets

    public final boolean autoCommitFailureClosesAllResultSets()
                                                       throws SQLException

Retrieves whether an `SQLException` will cause all open `ResultSet`s to be closed when auto-commit is `true`.

Specified by:
  `autoCommitFailureClosesAllResultSets` in interface `DatabaseMetaData`
Returns:
  `false`, since Derby does not close all open result sets when an error occurs
Throws:
  `SQLException` - if a database access error occurs

#### getSchemas

    public ResultSet getSchemas(String catalog,
                       String schemaPattern)
                         throws SQLException

Get the schema names available in this database. The results are ordered by schema name.

The schema columns are:

1. TABLE_SCHEM String => schema name
2. TABLE_CATALOG String => catalog name (may be `null`)

Specified by:
  `getSchemas` in interface `DatabaseMetaData`
Parameters:
  `catalog` - catalog name used to narrow down the search; "" means no catalog, `null` means any catalog
  `schemaPattern` - schema name used to narrow down the search, `null` means schema name should not be used to narrow down search
Returns:
  a `ResultSet` object in which each row is a schema description
Throws:
  `SQLException` - if a database error occurs

#### getClientInfoProperties

    public ResultSet getClientInfoProperties()
                                      throws SQLException

Returns a list of the client info properties supported by the driver. The result set contains the following columns:

1. NAME String=> The name of the client info property.
2. MAX_LEN int=> The maximum length of the value for the property.
3. DEFAULT_VALUE String=> The default value of the property.
4. DESCRIPTION String=> A description of the property.

The `ResultSet` is sorted by the NAME column.

Specified by:
  `getClientInfoProperties` in interface `DatabaseMetaData`
Returns:
  A `ResultSet` object; each row is a supported client info property
Throws:
  `SQLException` - if an error occurs

#### checkForClosedConnection

    protected void checkForClosedConnection()
                                     throws SQLException

A "public" version of checkForClosedConnection() that throws SQLException instead of SqlException. In particular this is used by all the DatabaseMetadata methods

Throws:
  `SQLException`

#### checkServerJdbcVersionX

    protected void checkServerJdbcVersionX(String method,
                               int major,
                               int minor)
                                    throws SqlException

Checks whether the server supports a JDBC version. If the server does not support the JDBC version, an exception is thrown.

Parameters:
  `method` - name of the method for which support is needed on the server (used in exception message)
  `major` - minimum JDBC major version
  `minor` - minimum JDBC minor version if major version matches
Throws:
  `SqlException` - if the server does not support the specified JDBC version