com.amazon.redshift.jdbc

## Class RedshiftDatabaseMetaData

- java.lang.Object
- - com.amazon.redshift.jdbc.RedshiftDatabaseMetaData

All Implemented Interfaces:
  DatabaseMetaData, Wrapper

    public class RedshiftDatabaseMetaData
    extends Object
    implements DatabaseMetaData

### Field Summary

Fields
`protected RedshiftConnectionImpl` `connection`

### 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
Constructor and Description
`RedshiftDatabaseMetaData(RedshiftConnectionImpl conn)`

### Method Summary

All Methods Instance Methods Concrete Methods
`boolean` `allProceduresAreCallable()`
`boolean` `allTablesAreSelectable()`
`boolean` `autoCommitFailureClosesAllResultSets()`
`protected Statement` `createMetaDataStatement()`
`boolean` `dataDefinitionCausesTransactionCommit()` Does a data definition statement within a transaction force the transaction to commit? It seems to mean something like:
`boolean` `dataDefinitionIgnoredInTransactions()`
`boolean` `deletesAreDetected(int i)`
`boolean` `doesMaxRowSizeIncludeBlobs()`
`protected String` `escapeOnlyQuotes(String s)`
`protected String` `escapeQuotes(String s)` Turn the provided value into a valid string literal for direct inclusion into a query.
`boolean` `generatedKeyAlwaysReturned()`
`ResultSet` `getAttributes(String catalog, String schemaPattern, String typeNamePattern, String attributeNamePattern)`
`ResultSet` `getBestRowIdentifier(String catalog, String schema, String table, int scope, boolean nullable)`
`ResultSet` `getCatalogs()` Redshift does not support multiple catalogs from a single connection, so to reduce confusion we only return the current catalog.
`String` `getCatalogSeparator()`
`String` `getCatalogTerm()`
`ResultSet` `getClientInfoProperties()`
`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()` Retrieves the name of this database product.
`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 columnNamePattern)`
`ResultSet` `getFunctions(String catalog, String schemaPattern, String functionNamePattern)`
`String` `getIdentifierQuoteString()` What is the string used to quote SQL identifiers? This returns a space if identifier quoting isn't supported.
`protected ResultSet` `getImportedExportedKeys(String primaryCatalog, String primarySchema, String primaryTable, String foreignCatalog, String foreignSchema, String foreignTable)`
`ResultSet` `getImportedKeys(String catalog, String schema, String table)`
`ResultSet` `getIndexInfo(String catalog, String schema, String tableName, 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()` What is the maximum number of columns in a table? From the CREATE TABLE reference page...
`int` `getMaxConnections()` How many active connection can we have at a time to this database? Well, since it depends on postmaster, which just does a listen() followed by an accept() and fork(), its basically very high.
`int` `getMaxCursorNameLength()`
`protected int` `getMaxIndexKeys()`
`int` `getMaxIndexLength()`
`long` `getMaxLogicalLobSize()`
`protected int` `getMaxNameLength()`
`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()`
`ResultSet` `getPseudoColumns(String catalog, String schemaPattern, String tableNamePattern, String columnNamePattern)`
`int` `getResultSetHoldability()`
`RowIdLifetime` `getRowIdLifetime()`
`ResultSet` `getSchemas()`
`ResultSet` `getSchemas(String catalog, String schemaPattern)`
`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` `getUDTs(String catalog, String schemaPattern, String typeNamePattern, int[] types)`
`String` `getURL()`
`String` `getUserName()`
`ResultSet` `getVersionColumns(String catalog, String schema, String table)`
`boolean` `insertsAreDetected(int type)`
`boolean` `isCatalogAtStart()`
`boolean` `isReadOnly()`
`boolean` `isSingleDatabaseMetaData()`
`boolean` `isWrapperFor(Class<?> iface)`
`boolean` `locatorsUpdateCopy()`
`boolean` `nullPlusNonNullIsNull()`
`boolean` `nullsAreSortedAtEnd()`
`boolean` `nullsAreSortedAtStart()`
`boolean` `nullsAreSortedHigh()`
`boolean` `nullsAreSortedLow()`
`boolean` `othersDeletesAreVisible(int i)`
`boolean` `othersInsertsAreVisible(int type)`
`boolean` `othersUpdatesAreVisible(int type)`
`boolean` `ownDeletesAreVisible(int type)`
`boolean` `ownInsertsAreVisible(int type)`
`boolean` `ownUpdatesAreVisible(int type)`
`Map<String,Map<String,List<String[]>>>` `parseACL(String aclArray, String owner)` Take the a String representing an array of ACLs and return a Map mapping the SQL permission name to a List of usernames who have that permission.
`boolean` `storesLowerCaseIdentifiers()`
`boolean` `storesLowerCaseQuotedIdentifiers()`
`boolean` `storesMixedCaseIdentifiers()`
`boolean` `storesMixedCaseQuotedIdentifiers()`
`boolean` `storesUpperCaseIdentifiers()`
`boolean` `storesUpperCaseQuotedIdentifiers()`
`boolean` `supportsAlterTableWithAddColumn()`
`boolean` `supportsAlterTableWithDropColumn()`
`boolean` `supportsANSI92EntryLevelSQL()` Does this driver support the ANSI-92 entry level SQL grammar? All JDBC Compliant drivers must return true.
`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()` Does this driver support the Core ODBC SQL grammar.
`boolean` `supportsCorrelatedSubqueries()`
`boolean` `supportsDataDefinitionAndDataManipulationTransactions()`
`boolean` `supportsDataManipulationTransactionsOnly()`
`boolean` `supportsDifferentTableCorrelationNames()`
`boolean` `supportsExpressionsInOrderBy()`
`boolean` `supportsExtendedSQLGrammar()` Does this driver support the Extended (Level 2) ODBC SQL grammar.
`boolean` `supportsFullOuterJoins()`
`boolean` `supportsGetGeneratedKeys()`
`boolean` `supportsGroupBy()`
`boolean` `supportsGroupByBeyondSelect()`
`boolean` `supportsGroupByUnrelated()`
`boolean` `supportsIntegrityEnhancementFacility()`
`boolean` `supportsLikeEscapeClause()`
`boolean` `supportsLimitedOuterJoins()`
`boolean` `supportsMinimumSQLGrammar()`
`boolean` `supportsMixedCaseIdentifiers()` Does the database treat mixed case unquoted SQL identifiers as case sensitive and as a result store them in mixed case? A JDBC-Compliant driver will always return false.
`boolean` `supportsMixedCaseQuotedIdentifiers()` Does the database treat mixed case quoted SQL identifiers as case sensitive and as a result store them in mixed case? A JDBC compliant driver will always return true.
`boolean` `supportsMultipleOpenResults()`
`boolean` `supportsMultipleResultSets()`
`boolean` `supportsMultipleTransactions()`
`boolean` `supportsNamedParameters()`
`boolean` `supportsNonNullableColumns()`
`boolean` `supportsOpenCursorsAcrossCommit()` In Redshift, Cursors are only open within transactions.
`boolean` `supportsOpenCursorsAcrossRollback()`
`boolean` `supportsOpenStatementsAcrossCommit()`
`boolean` `supportsOpenStatementsAcrossRollback()`
`boolean` `supportsOrderByUnrelated()`
`boolean` `supportsOuterJoins()`
`boolean` `supportsPositionedDelete()` We support cursors for gets only it seems.
`boolean` `supportsPositionedUpdate()`
`boolean` `supportsRefCursors()`
`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()`
`boolean` `supportsStoredProcedures()`
`boolean` `supportsSubqueriesInComparisons()`
`boolean` `supportsSubqueriesInExists()`
`boolean` `supportsSubqueriesInIns()`
`boolean` `supportsSubqueriesInQuantifieds()`
`boolean` `supportsTableCorrelationNames()`
`boolean` `supportsTransactionIsolationLevel(int level)`
`boolean` `supportsTransactions()`
`boolean` `supportsUnion()`
`boolean` `supportsUnionAll()`
`<T> T` `unwrap(Class<T> iface)`
`boolean` `updatesAreDetected(int type)`
`boolean` `usesLocalFilePerTable()` Does the database use a file for each table? Well, not really, since it doesn't use local files.
`boolean` `usesLocalFiles()` Does the database store tables in a local file? No - it stores them in a file on the server.

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

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

### Field Detail

#### connection

    protected final RedshiftConnectionImpl connection

### Constructor Detail

#### RedshiftDatabaseMetaData

    public RedshiftDatabaseMetaData(RedshiftConnectionImpl conn)

### Method Detail

#### getMaxIndexKeys

    protected int getMaxIndexKeys()
                           throws SQLException

Throws:
  `SQLException`

#### getMaxNameLength

    protected int getMaxNameLength()
                            throws SQLException

Throws:
  `SQLException`

#### 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`

#### 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`

#### 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`

#### getDatabaseProductName

    public String getDatabaseProductName()
                                  throws SQLException

Retrieves the name of this database product. We hope that it is Redshift, so we return that explicitly.

Specified by:
  `getDatabaseProductName` in interface `DatabaseMetaData`
Returns:
  "Redshift"
Throws:
  `SQLException`

#### getDatabaseProductVersion

    public String getDatabaseProductVersion()
                                     throws SQLException

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

#### getDriverName

    public String getDriverName()

Specified by:
  `getDriverName` in interface `DatabaseMetaData`

#### getDriverVersion

    public String getDriverVersion()

Specified by:
  `getDriverVersion` in interface `DatabaseMetaData`

#### getDriverMajorVersion

    public int getDriverMajorVersion()

Specified by:
  `getDriverMajorVersion` in interface `DatabaseMetaData`

#### getDriverMinorVersion

    public int getDriverMinorVersion()

Specified by:
  `getDriverMinorVersion` in interface `DatabaseMetaData`

#### usesLocalFiles

    public boolean usesLocalFiles()
                           throws SQLException

Does the database store tables in a local file? No - it stores them in a file on the server.

Specified by:
  `usesLocalFiles` in interface `DatabaseMetaData`
Returns:
  true if so
Throws:
  `SQLException` - if a database access error occurs

#### usesLocalFilePerTable

    public boolean usesLocalFilePerTable()
                                  throws SQLException

Does the database use a file for each table? Well, not really, since it doesn't use local files.

Specified by:
  `usesLocalFilePerTable` in interface `DatabaseMetaData`
Returns:
  true if so
Throws:
  `SQLException` - if a database access error occurs

#### supportsMixedCaseIdentifiers

    public boolean supportsMixedCaseIdentifiers()
                                         throws SQLException

Does the database treat mixed case unquoted SQL identifiers as case sensitive and as a result store them in mixed case? A JDBC-Compliant driver will always return false.

Specified by:
  `supportsMixedCaseIdentifiers` in interface `DatabaseMetaData`
Returns:
  true if so
Throws:
  `SQLException` - if a database access error occurs

#### 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`

#### supportsMixedCaseQuotedIdentifiers

    public boolean supportsMixedCaseQuotedIdentifiers()
                                               throws SQLException

Does the database treat mixed case quoted SQL identifiers as case sensitive and as a result store them in mixed case? A JDBC compliant driver will always return true.

Specified by:
  `supportsMixedCaseQuotedIdentifiers` in interface `DatabaseMetaData`
Returns:
  true if so
Throws:
  `SQLException` - if a database access error occurs

#### 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`

#### getIdentifierQuoteString

    public String getIdentifierQuoteString()
                                    throws SQLException

What is the string used to quote SQL identifiers? This returns a space if identifier quoting isn't supported. A JDBC Compliant driver will always use a double quote character.

Specified by:
  `getIdentifierQuoteString` in interface `DatabaseMetaData`
Returns:
  the quoting string
Throws:
  `SQLException` - if a database access error occurs

#### getSQLKeywords

    public String getSQLKeywords()
                          throws SQLException

From PostgreSQL 9.0+ return the keywords from pg_catalog.pg_get_keywords()

Specified by:
  `getSQLKeywords` in interface `DatabaseMetaData`
Returns:
  a comma separated list of keywords we use
Throws:
  `SQLException` - if a database access error occurs

#### 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

Redshift allows any high-bit character to be used in an unquoted identifier, so we can't possibly list them all.

From the file src/backend/parser/scan.l, an identifier is ident_start [A-Za-z\200-\377_] ident_cont [A-Za-z\200-\377_0-9\$] identifier {ident_start}{ident_cont}*

Specified by:
  `getExtraNameCharacters` in interface `DatabaseMetaData`
Returns:
  a string containing the extra characters
Throws:
  `SQLException` - if a database access error occurs

#### supportsAlterTableWithAddColumn

    public boolean supportsAlterTableWithAddColumn()
                                            throws SQLException

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

#### supportsAlterTableWithDropColumn

    public boolean supportsAlterTableWithDropColumn()
                                             throws SQLException

Specified by:
  `supportsAlterTableWithDropColumn` in interface `DatabaseMetaData`
Returns:
  true
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`

#### 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`

#### supportsTableCorrelationNames

    public boolean supportsTableCorrelationNames()
                                          throws SQLException

Specified by:
  `supportsTableCorrelationNames` 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`
Returns:
  true
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`
Returns:
  true
Throws:
  `SQLException`

#### supportsGroupByBeyondSelect

    public boolean supportsGroupByBeyondSelect()
                                        throws SQLException

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

#### supportsLikeEscapeClause

    public boolean supportsLikeEscapeClause()
                                     throws SQLException

Specified by:
  `supportsLikeEscapeClause` 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`

#### supportsNonNullableColumns

    public boolean supportsNonNullableColumns()
                                       throws SQLException

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

#### supportsMinimumSQLGrammar

    public boolean supportsMinimumSQLGrammar()
                                      throws SQLException

This grammar is defined at: http://www.microsoft.com/msdn/sdk/platforms/doc/odbc/src/intropr.htm

In Appendix C. From this description, we seem to support the ODBC minimal (Level 0) grammar.

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

#### supportsCoreSQLGrammar

    public boolean supportsCoreSQLGrammar()
                                   throws SQLException

Does this driver support the Core ODBC SQL grammar. We need SQL-92 conformance for this.

Specified by:
  `supportsCoreSQLGrammar` in interface `DatabaseMetaData`
Returns:
  false
Throws:
  `SQLException` - if a database access error occurs

#### supportsExtendedSQLGrammar

    public boolean supportsExtendedSQLGrammar()
                                       throws SQLException

Does this driver support the Extended (Level 2) ODBC SQL grammar. We don't conform to the Core (Level 1), so we can't conform to the Extended SQL Grammar.

Specified by:
  `supportsExtendedSQLGrammar` in interface `DatabaseMetaData`
Returns:
  false
Throws:
  `SQLException` - if a database access error occurs

#### supportsANSI92EntryLevelSQL

    public boolean supportsANSI92EntryLevelSQL()
                                        throws SQLException

Does this driver support the ANSI-92 entry level SQL grammar? All JDBC Compliant drivers must return true. We currently report false until 'schema' support is added. Then this should be changed to return true, since we will be mostly compliant (probably more compliant than many other databases) And since this is a requirement for all JDBC drivers we need to get to the point where we can return true.

Specified by:
  `supportsANSI92EntryLevelSQL` in interface `DatabaseMetaData`
Returns:
  true
Throws:
  `SQLException` - if a database access error occurs

#### supportsANSI92IntermediateSQL

    public boolean supportsANSI92IntermediateSQL()
                                          throws SQLException

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

#### supportsANSI92FullSQL

    public boolean supportsANSI92FullSQL()
                                  throws SQLException

Specified by:
  `supportsANSI92FullSQL` in interface `DatabaseMetaData`
Returns:
  false
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`
Returns:
  true
Throws:
  `SQLException`

#### supportsFullOuterJoins

    public boolean supportsFullOuterJoins()
                                   throws SQLException

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

#### supportsLimitedOuterJoins

    public boolean supportsLimitedOuterJoins()
                                      throws SQLException

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

#### getSchemaTerm

    public String getSchemaTerm()
                         throws SQLException

Redshift doesn't have schemas, but when it does, we'll use the term "schema".

Specified by:
  `getSchemaTerm` in interface `DatabaseMetaData`
Returns:
  `"schema"`
Throws:
  `SQLException`

#### getProcedureTerm

    public String getProcedureTerm()
                            throws SQLException

Specified by:
  `getProcedureTerm` in interface `DatabaseMetaData`
Returns:
  `"procedure"`
Throws:
  `SQLException`

#### getCatalogTerm

    public String getCatalogTerm()
                          throws SQLException

Specified by:
  `getCatalogTerm` in interface `DatabaseMetaData`
Returns:
  `"database"`
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`
Returns:
  true
Throws:
  `SQLException`

#### supportsSchemasInProcedureCalls

    public boolean supportsSchemasInProcedureCalls()
                                            throws SQLException

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

#### supportsSchemasInTableDefinitions

    public boolean supportsSchemasInTableDefinitions()
                                              throws SQLException

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

#### supportsSchemasInIndexDefinitions

    public boolean supportsSchemasInIndexDefinitions()
                                              throws SQLException

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

#### supportsSchemasInPrivilegeDefinitions

    public boolean supportsSchemasInPrivilegeDefinitions()
                                                  throws SQLException

Specified by:
  `supportsSchemasInPrivilegeDefinitions` in interface `DatabaseMetaData`
Returns:
  true
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

We support cursors for gets only it seems. I dont see a method to get a positioned delete.

Specified by:
  `supportsPositionedDelete` in interface `DatabaseMetaData`
Returns:
  false
Throws:
  `SQLException` - if a database access error occurs

#### 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`
Returns:
  true
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`

#### 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`
Returns:
  true
Throws:
  `SQLException`

#### supportsUnion

    public boolean supportsUnion()
                          throws SQLException

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

#### supportsUnionAll

    public boolean supportsUnionAll()
                             throws SQLException

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

#### supportsOpenCursorsAcrossCommit

    public boolean supportsOpenCursorsAcrossCommit()
                                            throws SQLException

In Redshift, Cursors are only open within transactions.

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

Can statements remain open across commits? They may, but this driver cannot guarantee that. In further reflection. we are talking a Statement object here, so the answer is yes, since the Statement is only a vehicle to ExecSQL()

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

#### supportsOpenStatementsAcrossRollback

    public boolean supportsOpenStatementsAcrossRollback()
                                                 throws SQLException

Can statements remain open across rollbacks? They may, but this driver cannot guarantee that. In further contemplation, we are talking a Statement object here, so the answer is yes, since the Statement is only a vehicle to ExecSQL() in Connection

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

#### getMaxCharLiteralLength

    public int getMaxCharLiteralLength()
                                throws SQLException

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

#### getMaxBinaryLiteralLength

    public int getMaxBinaryLiteralLength()
                                  throws SQLException

Specified by:
  `getMaxBinaryLiteralLength` 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

What is the maximum number of columns in a table? From the CREATE TABLE reference page...

"The new class is created as a heap with no initial data. A class can have no more than 1600 attributes (realistically, this is limited by the fact that tuple sizes must be less than 8192 bytes)..."

Specified by:
  `getMaxColumnsInTable` in interface `DatabaseMetaData`
Returns:
  the max columns
Throws:
  `SQLException` - if a database access error occurs

#### getMaxConnections

    public int getMaxConnections()
                          throws SQLException

How many active connection can we have at a time to this database? Well, since it depends on postmaster, which just does a listen() followed by an accept() and fork(), its basically very high. Unless the system runs out of processes, it can be 65535 (the number of aux. ports on a TCP/IP system). I will return 8192 since that is what even the largest system can realistically handle,

Specified by:
  `getMaxConnections` in interface `DatabaseMetaData`
Returns:
  the maximum number of connections
Throws:
  `SQLException` - if a database access error occurs

#### 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

We only support TRANSACTION_SERIALIZABLE and TRANSACTION_READ_COMMITTED before 8.0; from 8.0 READ_UNCOMMITTED and REPEATABLE_READ are accepted aliases for READ_COMMITTED.

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

Does a data definition statement within a transaction force the transaction to commit? It seems to mean something like:

     CREATE TABLE T (A INT);
     INSERT INTO T (A) VALUES (2);
     BEGIN;
     UPDATE T SET A = A + 1;
     CREATE TABLE X (A INT);
     SELECT A FROM T INTO X;
     COMMIT;

Does the CREATE TABLE call cause a commit? The answer is no.

Specified by:
  `dataDefinitionCausesTransactionCommit` in interface `DatabaseMetaData`
Returns:
  true if so
Throws:
  `SQLException` - if a database access error occurs

#### dataDefinitionIgnoredInTransactions

    public boolean dataDefinitionIgnoredInTransactions()
                                                throws SQLException

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

#### escapeQuotes

    protected String escapeQuotes(String s)
                           throws SQLException

Turn the provided value into a valid string literal for direct inclusion into a query. This includes the single quotes needed around it.

Parameters:
  `s` - input value
Returns:
  string literal for direct inclusion into a query
Throws:
  `SQLException` - if something wrong happens

#### escapeOnlyQuotes

    protected String escapeOnlyQuotes(String s)
                               throws SQLException

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`

#### 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`

#### getSchemas

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

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

#### getCatalogs

    public ResultSet getCatalogs()
                          throws SQLException

Redshift does not support multiple catalogs from a single connection, so to reduce confusion we only return the current catalog.

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`

#### parseACL

    public Map<String,Map<String,List<String[]>>> parseACL(String aclArray,
                                                           String owner)

Take the a String representing an array of ACLs and return a Map mapping the SQL permission name to a List of usernames who have that permission. For instance: `SELECT -> user1 -> list of [grantor, grantable]`

Parameters:
  `aclArray` - ACL array
  `owner` - owner
Returns:
  a Map mapping the SQL permission name

#### 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`

#### getImportedExportedKeys

    protected ResultSet getImportedExportedKeys(String primaryCatalog,
                                                String primarySchema,
                                                String primaryTable,
                                                String foreignCatalog,
                                                String foreignSchema,
                                                String foreignTable)
                                         throws SQLException

Parameters:
  `primaryCatalog` - primary catalog
  `primarySchema` - primary schema
  `primaryTable` - if provided will get the keys exported by this table
  `foreignCatalog` - foreign catalog
  `foreignSchema` - foreign schema
  `foreignTable` - if provided will get the keys imported by this table
Returns:
  ResultSet
Throws:
  `SQLException` - if something wrong happens

#### 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`

#### getIndexInfo

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

Specified by:
  `getIndexInfo` 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 i)
                                    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 i)
                               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`

#### 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`

#### createMetaDataStatement

    protected Statement createMetaDataStatement()
                                         throws SQLException

Throws:
  `SQLException`

#### getMaxLogicalLobSize

    public long getMaxLogicalLobSize()
                              throws SQLException

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

#### supportsRefCursors

    public boolean supportsRefCursors()
                               throws SQLException

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

#### getRowIdLifetime

    public RowIdLifetime getRowIdLifetime()
                                   throws SQLException

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

#### supportsStoredFunctionsUsingCallSyntax

    public boolean supportsStoredFunctionsUsingCallSyntax()
                                                   throws SQLException

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

#### autoCommitFailureClosesAllResultSets

    public boolean autoCommitFailureClosesAllResultSets()
                                                 throws SQLException

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

#### getClientInfoProperties

    public ResultSet getClientInfoProperties()
                                      throws SQLException

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

#### isWrapperFor

    public boolean isWrapperFor(Class<?> iface)
                         throws SQLException

Specified by:
  `isWrapperFor` in interface `Wrapper`
Throws:
  `SQLException`

#### unwrap

    public <T> T unwrap(Class<T> iface)
                 throws SQLException

Specified by:
  `unwrap` in interface `Wrapper`
Throws:
  `SQLException`

#### getFunctions

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

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

#### getFunctionColumns

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

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

#### getPseudoColumns

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

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

#### generatedKeyAlwaysReturned

    public boolean generatedKeyAlwaysReturned()
                                       throws SQLException

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

#### supportsSavepoints

    public boolean supportsSavepoints()
                               throws SQLException

Specified by:
  `supportsSavepoints` 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()

Specified by:
  `getJDBCMajorVersion` in interface `DatabaseMetaData`

#### getJDBCMinorVersion

    public int getJDBCMinorVersion()

Specified by:
  `getJDBCMinorVersion` in interface `DatabaseMetaData`

#### 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`

#### isSingleDatabaseMetaData

    public boolean isSingleDatabaseMetaData()