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()`
  `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()`
  Is the SQL Integrity Enhancement Facility supported? Our best guess is that this means support for constraints
  `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`
    Returns:
      true if connected to PostgreSQL 6.4+
    Throws:
      `SQLException`

  - ### supportsLikeEscapeClause

    public boolean supportsLikeEscapeClause() throws SQLException
    Specified by:
      `supportsLikeEscapeClause` in interface `DatabaseMetaData`
    Returns:
      true if connected to PostgreSQL 7.1+
    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
    Is the SQL Integrity Enhancement Facility supported? Our best guess is that this means support for constraints
    Specified by:
      `supportsIntegrityEnhancementFacility` in interface `DatabaseMetaData`
    Returns:
      true
    Throws:
      `SQLException` - if a database access error occurs

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