Package org.postgresql.jdbc

# Class PgDatabaseMetaData

java.lang.Object
org.postgresql.jdbc.PgDatabaseMetaData

All Implemented Interfaces:
  `DatabaseMetaData`, `Wrapper`

public class PgDatabaseMetaData extends Object implements DatabaseMetaData

## Field Summary

Fields
Modifier and Type
Field
Description
`protected final PgConnection`
`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
Description
`PgDatabaseMetaData(PgConnection conn)`

## Method Summary

Modifier and Type
Method
Description
`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`
`escapeQuotes(String s)`
Turn the provided value into a valid string literal for direct inclusion into a query.
`boolean`
`generatedKeyAlwaysReturned()`
`ResultSet`
`getAttributes(@Nullable String catalog, @Nullable String schemaPattern, @Nullable String typeNamePattern, @Nullable String attributeNamePattern)`
`ResultSet`
`getBestRowIdentifier(@Nullable String catalog, @Nullable String schema, String table, int scope, boolean nullable)`
`ResultSet`
`getCatalogs()`
PostgreSQL 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(@Nullable String catalog, @Nullable String schema, String table, @Nullable String columnNamePattern)`
`ResultSet`
`getColumns(@Nullable String catalog, @Nullable String schemaPattern, @Nullable String tableNamePattern, @Nullable String columnNamePattern)`
`Connection`
`getConnection()`
`ResultSet`
`getCrossReference(@Nullable String primaryCatalog, @Nullable String primarySchema, String primaryTable, @Nullable String foreignCatalog, @Nullable 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(@Nullable String catalog, @Nullable String schema, String table)`
`String`
`getExtraNameCharacters()`
`ResultSet`
`getFunctionColumns(@Nullable String catalog, @Nullable String schemaPattern, @Nullable String functionNamePattern, @Nullable String columnNamePattern)`
`ResultSet`
`getFunctions(@Nullable String catalog, @Nullable String schemaPattern, @Nullable 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(@Nullable String primaryCatalog, @Nullable String primarySchema, @Nullable String primaryTable, @Nullable String foreignCatalog, @Nullable String foreignSchema, @Nullable String foreignTable)`
`ResultSet`
`getImportedKeys(@Nullable String catalog, @Nullable String schema, String table)`
`ResultSet`
`getIndexInfo(@Nullable String catalog, @Nullable 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(@Nullable String catalog, @Nullable String schema, String table)`
`protected ResultSet`
`getPrimaryUniqueKeys(@Nullable String catalog, @Nullable String schema, String table)`
`ResultSet`
`getProcedureColumns(@Nullable String catalog, @Nullable String schemaPattern, @Nullable String procedureNamePattern, @Nullable String columnNamePattern)`
`ResultSet`
`getProcedures(@Nullable String catalog, @Nullable String schemaPattern, @Nullable String procedureNamePattern)`
`String`
`getProcedureTerm()`
`ResultSet`
`getPseudoColumns(@Nullable String catalog, @Nullable String schemaPattern, @Nullable String tableNamePattern, @Nullable String columnNamePattern)`
`int`
`getResultSetHoldability()`
`RowIdLifetime`
`getRowIdLifetime()`
`ResultSet`
`getSchemas()`
`ResultSet`
`getSchemas(@Nullable String catalog, @Nullable String schemaPattern)`
`String`
`getSchemaTerm()`
`String`
`getSearchStringEscape()`
`String`
`getSQLKeywords()`
`int`
`getSQLStateType()`
`String`
`getStringFunctions()`
`ResultSet`
`getSuperTables(@Nullable String catalog, @Nullable String schemaPattern, @Nullable String tableNamePattern)`
`ResultSet`
`getSuperTypes(@Nullable String catalog, @Nullable String schemaPattern, @Nullable String typeNamePattern)`
`String`
`getSystemFunctions()`
`ResultSet`
`getTablePrivileges(@Nullable String catalog, @Nullable String schemaPattern, @Nullable String tableNamePattern)`
`ResultSet`
`getTables(@Nullable String catalog, @Nullable String schemaPattern, @Nullable String tableNamePattern, String @Nullable [] types)`
`ResultSet`
`getTableTypes()`
`String`
`getTimeDateFunctions()`
`ResultSet`
`getTypeInfo()`
`ResultSet`
`getUDTs(@Nullable String catalog, @Nullable String schemaPattern, @Nullable String typeNamePattern, int @Nullable [] types)`
`String`
`getURL()`
`String`
`getUserName()`
`ResultSet`
`getVersionColumns(@Nullable String catalog, @Nullable String schema, String table)`
`boolean`
`insertsAreDetected(int type)`
`boolean`
`isCatalogAtStart()`
`boolean`
`isReadOnly()`
`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<@Nullable String[]>>>`
`parseACL(@Nullable 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 PostgreSQL, 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`

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

`supportsSharding`

## Field Details

### connection

protected final PgConnection connection

## Constructor Details

### PgDatabaseMetaData

public PgDatabaseMetaData(PgConnection conn)

## Method Details

### 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 PostgreSQL, so we return that explicitly.

Specified by:
  `getDatabaseProductName` in interface `DatabaseMetaData`
Returns:
  "PostgreSQL"
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

Postgresql 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 if connected to PostgreSQL 6.1+
Throws:
  `SQLException`

### supportsAlterTableWithDropColumn

public boolean supportsAlterTableWithDropColumn() throws SQLException

Specified by:
  `supportsAlterTableWithDropColumn` in interface `DatabaseMetaData`
Returns:
  true if connected to PostgreSQL 7.3+
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 if connected to PostgreSQL 6.4+
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 if connected to PostgreSQL 6.4+
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 if connected to PostgreSQL 7.3+
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 if connected to PostgreSQL 7.1+
Throws:
  `SQLException`

### supportsFullOuterJoins

public boolean supportsFullOuterJoins() throws SQLException

Specified by:
  `supportsFullOuterJoins` in interface `DatabaseMetaData`
Returns:
  true if connected to PostgreSQL 7.1+
Throws:
  `SQLException`

### supportsLimitedOuterJoins

public boolean supportsLimitedOuterJoins() throws SQLException

Specified by:
  `supportsLimitedOuterJoins` in interface `DatabaseMetaData`
Returns:
  true if connected to PostgreSQL 7.1+
Throws:
  `SQLException`

### getSchemaTerm

public String getSchemaTerm() throws SQLException

PostgreSQL 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:
  `"function"`
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 if connected to PostgreSQL 7.3+
Throws:
  `SQLException`

### supportsSchemasInProcedureCalls

public boolean supportsSchemasInProcedureCalls() throws SQLException

Specified by:
  `supportsSchemasInProcedureCalls` in interface `DatabaseMetaData`
Returns:
  true if connected to PostgreSQL 7.3+
Throws:
  `SQLException`

### supportsSchemasInTableDefinitions

public boolean supportsSchemasInTableDefinitions() throws SQLException

Specified by:
  `supportsSchemasInTableDefinitions` in interface `DatabaseMetaData`
Returns:
  true if connected to PostgreSQL 7.3+
Throws:
  `SQLException`

### supportsSchemasInIndexDefinitions

public boolean supportsSchemasInIndexDefinitions() throws SQLException

Specified by:
  `supportsSchemasInIndexDefinitions` in interface `DatabaseMetaData`
Returns:
  true if connected to PostgreSQL 7.3+
Throws:
  `SQLException`

### supportsSchemasInPrivilegeDefinitions

public boolean supportsSchemasInPrivilegeDefinitions() throws SQLException

Specified by:
  `supportsSchemasInPrivilegeDefinitions` in interface `DatabaseMetaData`
Returns:
  true if connected to PostgreSQL 7.3+
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 if connected to PostgreSQL 6.5+
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 if connected to PostgreSQL 7.1+
Throws:
  `SQLException`

### supportsUnion

public boolean supportsUnion() throws SQLException

Specified by:
  `supportsUnion` in interface `DatabaseMetaData`
Returns:
  true if connected to PostgreSQL 6.3+
Throws:
  `SQLException`

### supportsUnionAll

public boolean supportsUnionAll() throws SQLException

Specified by:
  `supportsUnionAll` in interface `DatabaseMetaData`
Returns:
  true if connected to PostgreSQL 7.1+
Throws:
  `SQLException`

### supportsOpenCursorsAcrossCommit

public boolean supportsOpenCursorsAcrossCommit() throws SQLException
In PostgreSQL, 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

### getProcedures

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

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

### getProcedureColumns

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

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

### getTables

public ResultSet getTables(@Nullable String catalog, @Nullable String schemaPattern, @Nullable String tableNamePattern, String @Nullable [] 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(@Nullable String catalog, @Nullable String schemaPattern) throws SQLException

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

### getCatalogs

public ResultSet getCatalogs() throws SQLException
PostgreSQL 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(@Nullable String catalog, @Nullable String schemaPattern, @Nullable String tableNamePattern, @Nullable String columnNamePattern) throws SQLException

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

### getColumnPrivileges

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

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

### getTablePrivileges

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

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

### parseACL

public Map<String,Map<String,List<@Nullable String[]>>> parseACL(@Nullable 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(@Nullable String catalog, @Nullable String schema, String table, int scope, boolean nullable) throws SQLException

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

### getVersionColumns

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

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

### getPrimaryKeys

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

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

### getPrimaryUniqueKeys

protected ResultSet getPrimaryUniqueKeys(@Nullable String catalog, @Nullable String schema, String table) throws SQLException

Throws:
  `SQLException`

### getImportedExportedKeys

protected ResultSet getImportedExportedKeys(@Nullable String primaryCatalog, @Nullable String primarySchema, @Nullable String primaryTable, @Nullable String foreignCatalog, @Nullable String foreignSchema, @Nullable 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(@Nullable String catalog, @Nullable String schema, String table) throws SQLException

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

### getExportedKeys

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

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

### getCrossReference

public ResultSet getCrossReference(@Nullable String primaryCatalog, @Nullable String primarySchema, String primaryTable, @Nullable String foreignCatalog, @Nullable 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(@Nullable String catalog, @Nullable 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(@Nullable String catalog, @Nullable String schemaPattern, @Nullable String typeNamePattern, int @Nullable [] 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(@Nullable String catalog, @Nullable String schemaPattern, @Nullable String functionNamePattern) throws SQLException

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

### getFunctionColumns

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

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

### getPseudoColumns

public ResultSet getPseudoColumns(@Nullable String catalog, @Nullable String schemaPattern, @Nullable String tableNamePattern, @Nullable 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(@Nullable String catalog, @Nullable String schemaPattern, @Nullable String typeNamePattern) throws SQLException

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

### getSuperTables

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

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

### getAttributes

public ResultSet getAttributes(@Nullable String catalog, @Nullable String schemaPattern, @Nullable String typeNamePattern, @Nullable 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`