Overview  Package   Class  Tree  Deprecated  Index  Help 
 PREV CLASS   NEXT CLASS FRAMES    NO FRAMES    
SUMMARY: NESTED | FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD

org.jboss.dna.common.jdbc.model.spi
Class DatabaseBean

java.lang.Object
  extended by org.jboss.dna.common.jdbc.model.spi.CoreMetaDataBean
      extended by org.jboss.dna.common.jdbc.model.spi.DatabaseBean
All Implemented Interfaces:
Serializable, CoreMetaData, Database
public class DatabaseBean
extends CoreMetaDataBean
implements Database

Provides RDBMS wide meta data retrieved from java.sql.DatabaseMetaData.

Author:
Sergiy Litsenko
See Also:
Serialized Form

Constructor Summary
DatabaseBean()
          Default constructor
 
Method Summary
 void addCatalog(Catalog catalog)
          Adds Catalog
 void addException(DatabaseMetaDataMethodException exception)
          Adds the DatabaseMetaDataMethodException to the DatabaseMetadataProvider exception list
 void addNumericFunction(String functionName)
          Adds numeric function
 void addSchema(Schema schema)
          Adds Schema
 void addSQLKeyword(String sqlKeyword)
          Adds SQL keyword
 void addSqlTypeConversionPair(SqlTypeConversionPair sqlTypeConversionPair)
          Adds SqlTypeConversionPair
 void addSqlTypeInfo(SqlTypeInfo sqlTypeInfo)
          Adds SqlTypeInfo
 void addStoredProcedure(StoredProcedure storedProcedure)
          Adds Stored Procedure
 void addStringFunction(String functionName)
          Adds String function
 void addSupportedForwardOnlyResultSetConcurrency(ResultSetConcurrencyType resultSetConcurrencyType)
          Adds ResultSetConcurrencyType
 void addSupportedResultSetType(ResultSetType resultSetType)
          Adds supported ResultSetType
 void addSupportedScrollInsensitiveResultSetConcurrency(ResultSetConcurrencyType resultSetConcurrencyType)
          Adds ResultSetConcurrencyType
 void addSupportedScrollSensitiveResultSetConcurrency(ResultSetConcurrencyType resultSetConcurrencyType)
          Adds resultSetConcurrencyType
 void addSupportedTransactionIsolationLevelType(TransactionIsolationLevelType transactionIsolationLevelType)
          Adds TransactionIsolationLevelType
 void addSystemFunction(String functionName)
          Adds System function
 void addTable(Table table)
          Adds Table
 void addTableType(TableType tableType)
          Adds TableType
 void addTimeDateFunction(String functionName)
          Adds Time/Date function
 void addUserDefinedType(UserDefinedType udt)
          Adds UDT
 void deleteCatalog(Catalog catalog)
          Deletes Catalog
 void deleteNumericFunction(String functionName)
          Deletes numeric function
 void deleteSchema(Schema schema)
          Deletes Schema
 void deleteSQLKeyword(String sqlKeyword)
          Deletes SQL keyword
 void deleteSqlTypeConversionPair(SqlTypeConversionPair sqlTypeConversionPair)
          deletes SqlTypeConversionPair
 void deleteSqlTypeInfo(SqlTypeInfo sqlTypeInfo)
          Deletes SqlTypeInfo
 void deleteStoredProcedure(StoredProcedure storedProcedure)
          Deletes Stored Procedure
 void deleteStringFunction(String functionName)
          Deletes String function
 void deleteSupportedForwardOnlyResultSetConcurrency(ResultSetConcurrencyType resultSetConcurrencyType)
          Deletes ResultSetConcurrencyType
 void deleteSupportedResultSetType(ResultSetType resultSetType)
          Deletes supported ResultSetType
 void deleteSupportedScrollInsensitiveResultSetConcurrency(ResultSetConcurrencyType resultSetConcurrencyType)
          Delete ResultSetConcurrencyType
 void deleteSupportedScrollSensitiveResultSetConcurrency(ResultSetConcurrencyType resultSetConcurrencyType)
          deletes resultSetConcurrencyType
 void deleteSupportedTransactionIsolationLevelType(TransactionIsolationLevelType transactionIsolationLevelType)
          Deletes TransactionIsolationLevelType
 void deleteSystemFunction(String functionName)
          deletes System function
 void deleteTable(Table table)
          Deletes Table
 void deleteTableType(TableType tableType)
          Deletes TableType
 void deleteTimeDateFunction(String functionName)
          deletes Time/Date function
 void deleteUserDefinedType(UserDefinedType udt)
          Deletes UDT
 Catalog findCatalogByName(String catalogName)
          Finds catalog by its name.
 DatabaseMetaDataMethodException findException(String methodName)
          Searches the DatabaseMetaDataMethodException by method name
 Schema findSchemaByName(String catalog, String schemaName)
          Finds schema by its name.
 Set<SqlTypeConversionPair> findSqlTypeConversionPairBySrcType(String srcType)
          Searches set of SqlTypeConversionPair by SrcType
 SqlTypeInfo findSqlTypeInfoByTypeName(String typeName)
          Finds SQL type by its name.
 StoredProcedure findStoredProcedureByName(String catalog, String schema, String procedureName)
          Finds stored procedute by its name.
 Table findTableByName(String catalog, String schema, String tableName)
          Finds table by its name.
 TableType findTableTypeByTypeName(String typeName)
          Finds table type by its name.
 UserDefinedType findUserDefinedTypeByName(String catalog, String schema, String tableName)
          Finds UDT by its name.
 Set<Catalog> getCatalogs()
          Retrieves the catalogs available in this database
 String getCatalogSeparator()
          Retrieves the String that this database uses as the separator between a catalog and table name.
 String getCatalogTerm()
          Retrieves the database vendor's preferred term for "catalog".
 Integer getDatabaseMajorVersion()
          Retrieves the major version number of the underlying database.
 Integer getDatabaseMinorVersion()
          Retrieves the minor version number of the underlying database.
 String getDatabaseProductName()
          Retrieves the name of this database product.
 String getDatabaseProductVersion()
          Retrieves the version number of this database product.
 Integer getDefaultTransactionIsolation()
          Retrieves this database's default transaction isolation level.
 Integer getDriverMajorVersion()
          Retrieves this JDBC driver's minor version number.
 Integer getDriverMinorVersion()
          Retrieves this JDBC driver's minor version number.
 String getDriverName()
          Retrieves the name of this JDBC driver.
 String getDriverVersion()
          Retrieves the version number of this JDBC driver as a String.
 List<DatabaseMetaDataMethodException> getExceptionList()
          Returns list of failed database metadata methods through the DatabaseMetaDataMethodExceptions
 String getExtraNameCharacters()
          Retrieves all the "extra" characters that can be used in unquoted identifier names (those beyond a-z, A-Z, 0-9 and _).
 String getIdentifierQuoteString()
          Retrieves the string used to quote SQL identifiers.
 Integer getJDBCMajorVersion()
          Retrieves the major JDBC version number for this driver.
 Integer getJDBCMinorVersion()
          Retrieves the minor JDBC version number for this driver.
 Integer getMaxBinaryLiteralLength()
          Retrieves the maximum number of hex characters this database allows in an inline binary literal.
 Integer getMaxCatalogNameLength()
          Retrieves the maximum number of characters that this database allows in a catalog name.
 Integer getMaxCharLiteralLength()
          Retrieves the maximum number of characters this database allows for a character literal.
 Integer getMaxColumnNameLength()
          Retrieves the maximum number of characters this database allows for a column name.
 Integer getMaxColumnsInGroupBy()
          Retrieves the maximum number of columns this database allows in a GROUP BY clause.
 Integer getMaxColumnsInIndex()
          Retrieves the maximum number of columns this database allows in an index.
 Integer getMaxColumnsInOrderBy()
          Retrieves the maximum number of columns this database allows in an ORDER BY clause.
 Integer getMaxColumnsInSelect()
          Retrieves the maximum number of columns this database allows in a SELECT list.
 Integer getMaxColumnsInTable()
          Retrieves the maximum number of columns this database allows in a table.
 Integer getMaxConnections()
          Retrieves the maximum number of concurrent connections to this database that are possible.
 Integer getMaxCursorNameLength()
          Retrieves the maximum number of characters that this database allows in a cursor name.
 Integer getMaxIndexLength()
          Retrieves the maximum number of bytes this database allows for an index, including all of the parts of the index.
 Integer getMaxProcedureNameLength()
          Retrieves the maximum number of characters that this database allows in a procedure name.
 Integer getMaxRowSize()
          Retrieves the maximum number of bytes this database allows in a single row.
 Integer getMaxSchemaNameLength()
          Retrieves the maximum number of characters that this database allows in a schema name.
 Integer getMaxStatementLength()
          Retrieves the maximum number of characters this database allows in an SQL statement.
 Integer getMaxStatements()
          Retrieves the maximum number of active statements to this database that can be open at the same time.
 Integer getMaxTableNameLength()
          Retrieves the maximum number of characters this database allows in a table name.
 Integer getMaxTablesInSelect()
          Retrieves the maximum number of tables this database allows in a SELECT statement.
 Integer getMaxUserNameLength()
          Retrieves the maximum number of characters this database allows in a user name.
 String getName()
          Gets database name
 Set<String> getNumericFunctions()
          Retrieves a list of math functions available with this database.
 String getProcedureTerm()
          Retrieves the database vendor's preferred term for "procedure".
 ResultSetHoldabilityType getResultSetHoldabilityType()
          Retrieves the default holdability of this ResultSet object.
 Set<Schema> getSchemas()
          Retrieves the schemas available in this database.
 String getSchemaTerm()
          Retrieves the database vendor's preferred term for "schema".
 String getSearchStringEscape()
          Retrieves the string that can be used to escape wildcard characters.
 Set<String> getSQLKeywords()
          Retrieves a list of all of this database's SQL keywords that are NOT also SQL92 keywords.
 SQLStateType getSQLStateType()
          Indicates whether the SQLSTATE returned by SQLException.getSQLState is X/Open (now known as Open Group) SQL CLI or SQL99.
 Set<SqlTypeInfo> getSqlTypeInfos()
          Retrieves a description of all the standard SQL types supported by this database
 Set<StoredProcedure> getStoredProcedures()
          Retrieves a description of the stored procedures available in the given catalog.
 Set<String> getStringFunctions()
          Retrieves a list of string functions available with this database.
 Set<SqlTypeConversionPair> getSupportedConversions()
          Retrieves whether this database supports the CONVERT for given SQL types.
 Set<ResultSetConcurrencyType> getSupportedForwardOnlyResultSetConcurrencies()
          Retrieves database supported concurrencies for the given result set type.
 Set<ResultSetType> getSupportedResultSetTypes()
          Retrieves database supported result set types.
 Set<ResultSetConcurrencyType> getSupportedScrollInsensitiveResultSetConcurrencies()
          Retrieves database supported concurrencies for the given result set type.
 Set<ResultSetConcurrencyType> getSupportedScrollSensitiveResultSetConcurrencies()
          Retrieves database supported concurrencies for the given result set type.
 Set<TransactionIsolationLevelType> getSupportedTransactionIsolationLevels()
          Retrieves list of database supported transaction isolation levels.
 Set<String> getSystemFunctions()
          Retrieves a list of system functions available with this database.
 Set<Table> getTables()
          Retrieves a description of the tables available in the given catalog.
 Set<TableType> getTableTypes()
          Retrieves the table types available in this database.
 Set<String> getTimeDateFunctions()
          Retrieves a list of the time and date functions available with this database.
 String getURL()
          Retrieves the URL for this DBMS.
 Set<UserDefinedType> getUserDefinedTypes()
          Retrieves a description of the UDT available in the given catalog.
 String getUserName()
          Retrieves the user name as known to this database.
 Boolean isAllProceduresAreCallable()
          Retrieves whether the current user can call all the procedures returned by the method DatabaseMetaData.getProcedures.
 Boolean isAllTablesAreSelectable()
          Retrieves whether the current user can use all the tables returned by the method DatabaseMetaData.getTables in a SELECT statement.
 Boolean isCatalogAtStart()
          Retrieves whether a catalog appears at the start of a fully qualified table name.
 boolean isDatabaseMetaDataMethodFailed(String methodName)
          Checks that specified database metadata method of provider is failed or not
 Boolean isDataDefinitionCausesTransactionCommit()
          Retrieves whether a data definition statement within a transaction forces the transaction to commit.
 Boolean isDataDefinitionIgnoredInTransactions()
          Retrieves whether this database ignores a data definition statement within a transaction.
 Boolean isForwardOnlyResultInsertsAreDetected()
          Retrieves whether or not a visible row insert can be detected by calling the method ResultSet.rowInserted.
 Boolean isForwardOnlyResultSetDeletesAreDetected()
          Retrieves whether or not a visible row delete can be detected by calling the method ResultSet.rowDeleted.
 Boolean isForwardOnlyResultSetOthersDeletesAreVisible()
          Retrieves whether deletes made by others are visible.
 Boolean isForwardOnlyResultSetOthersInsertsAreVisible()
          Retrieves whether inserts made by others are visible.
 Boolean isForwardOnlyResultSetOthersUpdatesAreVisible()
          Retrieves whether updates made by others are visible.
 Boolean isForwardOnlyResultSetOwnDeletesAreVisible()
          Retrieves whether a result set's own deletes are visible.
 Boolean isForwardOnlyResultSetOwnInsertsAreVisible()
          Retrieves whether a result set's own inserts are visible.
 Boolean isForwardOnlyResultSetOwnUpdatesAreVisible()
          Retrieves whether for the given type of ResultSet object, the result set's own updates are visible.
 Boolean isForwardOnlyResultSetUpdatesAreDetected()
          Retrieves whether or not a visible row update can be detected by calling the method ResultSet.rowUpdated.
 Boolean isLocatorsUpdateCopy()
          Indicates whether updates made to a LOB are made on a copy or directly to the LOB.
 Boolean isMaxRowSizeIncludeBlobs()
          Retrieves whether the return value for the method getMaxRowSize includes the SQL data types LONGVARCHAR and LONGVARBINARY.
 Boolean isNullPlusNonNullIsNull()
          Retrieves whether this database supports concatenations between NULL and non-NULL values being NULL.
 Boolean isNullsAreSortedAtEnd()
          Retrieves whether NULL values are sorted at the end regardless of sort order.
 Boolean isNullsAreSortedAtStart()
          Retrieves whether NULL values are sorted at the start regardless of sort order.
 Boolean isNullsAreSortedHigh()
          Retrieves whether NULL values are sorted high.
 Boolean isNullsAreSortedLow()
          Retrieves whether NULL values are sorted low.
 Boolean isNumericFunctionSupported(String functionName)
          Is Numeric function supported
 Boolean isReadOnly()
          Retrieves whether this database is in read-only mode.
 Boolean isScrollInsensitiveResultInsertsAreDetected()
          Retrieves whether or not a visible row insert can be detected by calling the method ResultSet.rowInserted.
 Boolean isScrollInsensitiveResultSetDeletesAreDetected()
          Retrieves whether or not a visible row delete can be detected by calling the method ResultSet.rowDeleted.
 Boolean isScrollInsensitiveResultSetOthersDeletesAreVisible()
          Retrieves whether deletes made by others are visible.
 Boolean isScrollInsensitiveResultSetOthersInsertsAreVisible()
          Retrieves whether inserts made by others are visible.
 Boolean isScrollInsensitiveResultSetOthersUpdatesAreVisible()
          Retrieves whether updates made by others are visible.
 Boolean isScrollInsensitiveResultSetOwnDeletesAreVisible()
          Retrieves whether a result set's own deletes are visible.
 Boolean isScrollInsensitiveResultSetOwnInsertsAreVisible()
          Retrieves whether a result set's own inserts are visible.
 Boolean isScrollInsensitiveResultSetOwnUpdatesAreVisible()
          Retrieves whether for the given type of ResultSet object, the result set's own updates are visible.
 Boolean isScrollInsensitiveResultSetUpdatesAreDetected()
          Retrieves whether or not a visible row update can be detected by calling the method ResultSet.rowUpdated.
 Boolean isScrollSensitiveResultInsertsAreDetected()
          Retrieves whether or not a visible row insert can be detected by calling the method ResultSet.rowInserted.
 Boolean isScrollSensitiveResultSetDeletesAreDetected()
          Retrieves whether or not a visible row delete can be detected by calling the method ResultSet.rowDeleted.
 Boolean isScrollSensitiveResultSetOthersDeletesAreVisible()
          Retrieves whether deletes made by others are visible.
 Boolean isScrollSensitiveResultSetOthersInsertsAreVisible()
          Retrieves whether inserts made by others are visible.
 Boolean isScrollSensitiveResultSetOthersUpdatesAreVisible()
          Retrieves whether updates made by others are visible.
 Boolean isScrollSensitiveResultSetOwnDeletesAreVisible()
          Retrieves whether a result set's own deletes are visible.
 Boolean isScrollSensitiveResultSetOwnInsertsAreVisible()
          Retrieves whether a result set's own inserts are visible.
 Boolean isScrollSensitiveResultSetOwnUpdatesAreVisible()
          Retrieves whether for the given type of ResultSet object, the result set's own updates are visible.
 Boolean isScrollSensitiveResultSetUpdatesAreDetected()
          Retrieves whether or not a visible row update can be detected by calling the method ResultSet.rowUpdated.
 Boolean isSQLKeywordSupported(String sqlKeyword)
          Is SQL keyword supported
 Boolean isStoresLowerCaseIdentifiers()
          Retrieves whether this database treats mixed case unquoted SQL identifiers as case insensitive and stores them in lower case.
 Boolean isStoresLowerCaseQuotedIdentifiers()
          Retrieves whether this database treats mixed case quoted SQL identifiers as case insensitive and stores them in lower case.
 Boolean isStoresMixedCaseIdentifiers()
          Retrieves whether this database treats mixed case unquoted SQL identifiers as case insensitive and stores them in mixed case.
 Boolean isStoresMixedCaseQuotedIdentifiers()
          Retrieves whether this database treats mixed case quoted SQL identifiers as case insensitive and stores them in mixed case.
 Boolean isStoresUpperCaseIdentifiers()
          Retrieves whether this database treats mixed case unquoted SQL identifiers as case insensitive and stores them in upper case.
 Boolean isStoresUpperCaseQuotedIdentifiers()
          Retrieves whether this database treats mixed case quoted SQL identifiers as case insensitive and stores them in upper case.
 Boolean isStringFunctionSupported(String functionName)
          Is String function supported
 Boolean isSupportedTransactionIsolationLevelType(TransactionIsolationLevelType transactionIsolationLevelType)
          Is supported TransactionIsolationLevelType
 Boolean isSupportsAlterTableWithAddColumn()
          Retrieves whether this database supports ALTER TABLE with add column.
 Boolean isSupportsAlterTableWithDropColumn()
          Retrieves whether this database supports ALTER TABLE with drop column.
 Boolean isSupportsANSI92EntryLevelSQL()
          Retrieves whether this database supports the ANSI92 entry level SQL grammar.
 Boolean isSupportsANSI92FullSQL()
          Retrieves whether this database supports the ANSI92 full SQL grammar supported.
 Boolean isSupportsANSI92IntermediateSQL()
          Retrieves whether this database supports the ANSI92 intermediate SQL grammar supported.
 Boolean isSupportsBatchUpdates()
          Retrieves whether this database supports batch updates.
 Boolean isSupportsCatalogsInDataManipulation()
          Retrieves whether a catalog name can be used in a data manipulation statement.
 Boolean isSupportsCatalogsInIndexDefinitions()
          Retrieves whether a catalog name can be used in an index definition statement.
 Boolean isSupportsCatalogsInPrivilegeDefinitions()
          Retrieves whether a catalog name can be used in a privilege definition statement.
 Boolean isSupportsCatalogsInProcedureCalls()
          Retrieves whether a catalog name can be used in a procedure call statement.
 Boolean isSupportsCatalogsInTableDefinitions()
          Retrieves whether a catalog name can be used in a table definition statement.
 Boolean isSupportsColumnAliasing()
          Retrieves whether this database supports column aliasing.
 Boolean isSupportsConvert()
          Retrieves whether this database supports the CONVERT function between SQL types.
 Boolean isSupportsCoreSQLGrammar()
          Retrieves whether this database supports the ODBC Core SQL grammar.
 Boolean isSupportsCorrelatedSubqueries()
          Retrieves whether this database supports correlated subqueries.
 Boolean isSupportsDataDefinitionAndDataManipulationTransactions()
          Retrieves whether this database supports both data definition and data manipulation statements within a transaction.
 Boolean isSupportsDataManipulationTransactionsOnly()
          Retrieves whether this database supports only data manipulation statements within a transaction.
 Boolean isSupportsDifferentTableCorrelationNames()
          Retrieves whether, when table correlation names are supported, they are restricted to being different from the names of the tables.
 Boolean isSupportsExpressionsInOrderBy()
          Retrieves whether this database supports expressions in ORDER BY lists.
 Boolean isSupportsExtendedSQLGrammar()
          Retrieves whether this database supports the ODBC Extended SQL grammar.
 Boolean isSupportsFullOuterJoins()
          Retrieves whether this database supports full nested outer joins.
 Boolean isSupportsGetGeneratedKeys()
          Retrieves whether auto-generated keys can be retrieved after a statement has been executed.
 Boolean isSupportsGroupBy()
          Retrieves whether this database supports some form of GROUP BY clause.
 Boolean isSupportsGroupByBeyondSelect()
          Retrieves whether this database supports using columns not included in the SELECT statement in a GROUP BY clause provided that all of the columns in the SELECT statement are included in the GROUP BY clause.
 Boolean isSupportsGroupByUnrelated()
          Retrieves whether this database supports using a column that is not in the SELECT statement in a GROUP BY clause.
 Boolean isSupportsIntegrityEnhancementFacility()
          Retrieves whether this database supports the SQL Integrity Enhancement Facility.
 Boolean isSupportsLikeEscapeClause()
          Retrieves whether this database supports specifying a LIKE escape clause.
 Boolean isSupportsLimitedOuterJoins()
          Retrieves whether this database provides limited support for outer joins.
 Boolean isSupportsMinimumSQLGrammar()
          Retrieves whether this database supports the ODBC Minimum SQL grammar.
 Boolean isSupportsMixedCaseIdentifiers()
          Retrieves whether this database treats mixed case unquoted SQL identifiers as case sensitive and as a result stores them in mixed case.
 Boolean isSupportsMixedCaseQuotedIdentifiers()
          Retrieves whether this database treats mixed case quoted SQL identifiers as case sensitive and as a result stores them in mixed case.
 Boolean isSupportsMultipleOpenResults()
          Retrieves whether it is possible to have multiple ResultSet objects returned from a CallableStatement object simultaneously.
 Boolean isSupportsMultipleResultSets()
          Retrieves whether this database supports getting multiple ResultSet objects from a single call to the method execute.
 Boolean isSupportsMultipleTransactions()
          Retrieves whether this database allows having multiple transactions open at once (on different connections).
 Boolean isSupportsNamedParameters()
          Retrieves whether this database supports named parameters to callable statements.
 Boolean isSupportsNonNullableColumns()
          Retrieves whether columns in this database may be defined as non-nullable.
 Boolean isSupportsOpenCursorsAcrossCommit()
          Retrieves whether this database supports keeping cursors open across commits.
 Boolean isSupportsOpenCursorsAcrossRollback()
          Retrieves whether this database supports keeping cursors open across rollbacks.
 Boolean isSupportsOpenStatementsAcrossCommit()
          Retrieves whether this database supports keeping statements open across commits.
 Boolean isSupportsOpenStatementsAcrossRollback()
          Retrieves whether this database supports keeping statements open across rollbacks.
 Boolean isSupportsOrderByUnrelated()
          Retrieves whether this database supports using a column that is not in the SELECT statement in an ORDER BY clause.
 Boolean isSupportsOuterJoins()
          Retrieves whether this database supports some form of outer join.
 Boolean isSupportsPositionedDelete()
          Retrieves whether this database supports positioned DELETE statements.
 Boolean isSupportsPositionedUpdate()
          Retrieves whether this database supports positioned UPDATE statements.
 Boolean isSupportsResultSetCloseCurrorsAtCommitHoldability()
          Retrieves whether this database supports the given result set holdability.
 Boolean isSupportsResultSetHoldCurrorsOverCommitHoldability()
          Retrieves whether this database supports the given result set holdability.
 Boolean isSupportsSavepoints()
          Retrieves whether this database supports savepoints.
 Boolean isSupportsSchemasInDataManipulation()
          Retrieves whether a schema name can be used in a data manipulation statement.
 Boolean isSupportsSchemasInIndexDefinitions()
          Retrieves whether a schema name can be used in an index definition statement.
 Boolean isSupportsSchemasInPrivilegeDefinitions()
          Retrieves whether a schema name can be used in a privilege definition statement.
 Boolean isSupportsSchemasInProcedureCalls()
          Retrieves whether a schema name can be used in a procedure call statement.
 Boolean isSupportsSchemasInTableDefinitions()
          Retrieves whether a schema name can be used in a table definition statement.
 Boolean isSupportsSelectForUpdate()
          Retrieves whether this database supports SELECT FOR UPDATE statements.
 Boolean isSupportsStatementPooling()
          Retrieves whether this database supports statement pooling.
 Boolean isSupportsStoredProcedures()
          Retrieves whether this database supports stored procedure calls that use the stored procedure escape syntax.
 Boolean isSupportsSubqueriesInComparisons()
          Retrieves whether this database supports subqueries in comparison expressions.
 Boolean isSupportsSubqueriesInExists()
          Retrieves whether this database supports subqueries in EXISTS expressions.
 Boolean isSupportsSubqueriesInIns()
          Retrieves whether this database supports subqueries in IN statements.
 Boolean isSupportsSubqueriesInQuantifieds()
          Retrieves whether this database supports subqueries in quantified expressions.
 Boolean isSupportsTableCorrelationNames()
          Retrieves whether this database supports table correlation names.
 Boolean isSupportsTransactions()
          Retrieves whether this database supports transactions.
 Boolean isSupportsUnion()
          Retrieves whether this database supports SQL UNION.
 Boolean isSupportsUnionAll()
          Retrieves whether this database supports SQL UNION ALL.
 Boolean isSystemFunctionSupported(String functionName)
          Is System function supported
 Boolean isTimeDateFunctionSupported(String functionName)
          Is Time/Date function supported
 Boolean isUsesLocalFilePerTable()
          Retrieves whether this database uses a file for each table.
 Boolean isUsesLocalFiles()
          Retrieves whether this database stores tables in a local file.
 void setAllProceduresAreCallable(Boolean allProceduresAreCallable)
          sets whether the current user can call all the procedures returned by the method DatabaseMetaData.getProcedures.
 void setAllTablesAreSelectable(Boolean allTablesAreSelectable)
          Sets whether the current user can use all the tables returned by the method DatabaseMetaData.getTables in a SELECT statement.
 void setCatalogAtStart(Boolean catalogAtStart)
          Sets whether a catalog appears at the start of a fully qualified table name.
 void setCatalogSeparator(String catalogSeparator)
          Sets the String that this database uses as the separator between a catalog and table name.
 void setCatalogTerm(String catalogTerm)
          Sets the database vendor's preferred term for "catalog".
 void setDatabaseMajorVersion(Integer databaseMajorVersion)
          Sets the major version number of the underlying database.
 void setDatabaseMinorVersion(Integer databaseMinorVersion)
          Sets the minor version number of the underlying database.
 void setDatabaseProductName(String databaseProductName)
          Sets the name of this database product.
 void setDatabaseProductVersion(String databaseProductVersion)
          Sets the version number of this database product.
 void setDataDefinitionCausesTransactionCommit(Boolean dataDefinitionCausesTransactionCommit)
          Sets whether a data definition statement within a transaction forces the transaction to commit.
 void setDataDefinitionIgnoredInTransactions(Boolean dataDefinitionIgnoredInTransactions)
          Sets whether this database ignores a data definition statement within a transaction.
 void setDefaultTransactionIsolation(Integer defaultTransactionIsolation)
          Sets this database's default transaction isolation level.
 void setDriverMajorVersion(Integer driverMajorVersion)
          Sets this JDBC driver's major version number.
 void setDriverMinorVersion(Integer driverMinorVersion)
          Sets this JDBC driver's minor version number.
 void setDriverName(String driverName)
          Sets the name of this JDBC driver.
 void setDriverVersion(String driverVersion)
          Sets the version number of this JDBC driver as a String.
 void setExtraNameCharacters(String extraNameCharacters)
          Sets all the "extra" characters that can be used in unquoted identifier names (those beyond a-z, A-Z, 0-9 and _).
 void setForwardOnlyResultInsertsAreDetected(Boolean forwardOnlyResultInsertsAreDetected)
          Sets whether or not a visible row insert can be detected by calling the method ResultSet.rowInserted.
 void setForwardOnlyResultSetDeletesAreDetected(Boolean forwardOnlyResultSetDeletesAreDetected)
          Sets whether or not a visible row delete can be detected by calling the method ResultSet.rowDeleted.
 void setForwardOnlyResultSetOthersDeletesAreVisible(Boolean forwardOnlyResultSetOthersDeletesAreVisible)
          Sets whether deletes made by others are visible.
 void setForwardOnlyResultSetOthersInsertsAreVisible(Boolean forwardOnlyResultSetOthersInsertsAreVisible)
          Sets whether inserts made by others are visible.
 void setForwardOnlyResultSetOthersUpdatesAreVisible(Boolean forwardOnlyResultSetOthersUpdatesAreVisible)
          Sets whether updates made by others are visible.
 void setForwardOnlyResultSetOwnDeletesAreVisible(Boolean forwardOnlyResultSetOwnDeletesAreVisible)
          Sets whether a result set's own deletes are visible.
 void setForwardOnlyResultSetOwnInsertsAreVisible(Boolean forwardOnlyResultSetOwnInsertsAreVisible)
          Sets whether a result set's own inserts are visible.
 void setForwardOnlyResultSetOwnUpdatesAreVisible(Boolean forwardOnlyResultSetOwnUpdatesAreVisible)
          Sets whether for the given type of ResultSet object, the result set's own updates are visible.
 void setForwardOnlyResultSetUpdatesAreDetected(Boolean forwardOnlyResultSetUpdatesAreDetected)
          Sets whether or not a visible row update can be detected by calling the method ResultSet.rowUpdated.
 void setIdentifierQuoteString(String identifierQuoteString)
          Sets the string used to quote SQL identifiers.
 void setJDBCMajorVersion(Integer jdbcMajorVersion)
          Sets the major JDBC version number for this driver.
 void setJDBCMinorVersion(Integer jdbcMinorVersion)
          Sets the minor JDBC version number for this driver.
 void setLocatorsUpdateCopy(Boolean locatorsUpdateCopy)
          Indicates whether updates made to a LOB are made on a copy or directly to the LOB.
 void setMaxBinaryLiteralLength(Integer maxBinaryLiteralLength)
          sets the maximum number of hex characters this database allows in an inline binary literal.
 void setMaxCatalogNameLength(Integer maxCatalogNameLength)
          Sets the maximum number of characters that this database allows in a catalog name.
 void setMaxCharLiteralLength(Integer maxCharLiteralLength)
          Sets the maximum number of characters this database allows for a character literal.
 void setMaxColumnNameLength(Integer maxColumnNameLength)
          Sets the maximum number of characters this database allows for a column name.
 void setMaxColumnsInGroupBy(Integer maxColumnsInGroupBy)
          Sets the maximum number of columns this database allows in a GROUP BY clause.
 void setMaxColumnsInIndex(Integer maxColumnsInIndex)
          Sets the maximum number of columns this database allows in an index.
 void setMaxColumnsInOrderBy(Integer maxColumnsInOrderBy)
          Sets the maximum number of columns this database allows in an ORDER BY clause.
 void setMaxColumnsInSelect(Integer maxColumnsInSelect)
          Sets the maximum number of columns this database allows in a SELECT list.
 void setMaxColumnsInTable(Integer maxColumnsInTable)
          Sets the maximum number of columns this database allows in a table.
 void setMaxConnections(Integer maxConnections)
          Sets the maximum number of concurrent connections to this database that are possible.
 void setMaxCursorNameLength(Integer maxCursorNameLength)
          Sets the maximum number of characters that this database allows in a cursor name.
 void setMaxIndexLength(Integer maxIndexLength)
          Sets the maximum number of bytes this database allows for an index, including all of the parts of the index.
 void setMaxProcedureNameLength(Integer maxProcedureNameLength)
          Sets the maximum number of characters that this database allows in a procedure name.
 void setMaxRowSize(Integer maxRowSize)
          Sets the maximum number of bytes this database allows in a single row.
 void setMaxRowSizeIncludeBlobs(Boolean maxRowSizeIncludeBlobs)
          Sets whether the return value for the method getMaxRowSize includes the SQL data types LONGVARCHAR and LONGVARBINARY.
 void setMaxSchemaNameLength(Integer maxSchemaNameLength)
          Sets the maximum number of characters that this database allows in a schema name.
 void setMaxStatementLength(Integer maxStatementLength)
          Sets the maximum number of characters this database allows in an SQL statement.
 void setMaxStatements(Integer maxStatements)
          Sets the maximum number of active statements to this database that can be open at the same time.
 void setMaxTableNameLength(Integer maxTableNameLength)
          Sets the maximum number of characters this database allows in a table name.
 void setMaxTablesInSelect(Integer maxTablesInSelect)
          Sets the maximum number of tables this database allows in a SELECT statement.
 void setMaxUserNameLength(Integer maxUserNameLength)
          Sets the maximum number of characters this database allows in a user name.
 void setName(String name)
          Sets database name
 void setNullPlusNonNullIsNull(Boolean nullPlusNonNullIsNull)
          Sets whether this database supports concatenations between NULL and non-NULL values being NULL.
 void setNullsAreSortedAtEnd(Boolean nullsAreSortedAtEnd)
          Sets whether NULL values are sorted at the end regardless of sort order.
 void setNullsAreSortedAtStart(Boolean nullsAreSortedAtStart)
          Sets whether NULL values are sorted at the start regardless of sort order.
 void setNullsAreSortedHigh(Boolean nullsAreSortedHigh)
          Sets whether NULL values are sorted high.
 void setNullsAreSortedLow(Boolean nullsAreSortedLow)
          Sets whether NULL values are sorted low.
 void setProcedureTerm(String procedureTerm)
          Sets the database vendor's preferred term for "procedure".
 void setReadOnly(Boolean readOnly)
          Sets whether this database is in read-only mode.
 void setResultSetHoldabilityType(ResultSetHoldabilityType resultSetHoldabilityType)
          Sets the default holdability of this ResultSet object.
 void setSchemaTerm(String schemaTerm)
          Sets the database vendor's preferred term for "schema".
 void setScrollInsensitiveResultInsertsAreDetected(Boolean scrollInsensitiveResultInsertsAreDetected)
          Sets whether or not a visible row insert can be detected by calling the method ResultSet.rowInserted.
 void setScrollInsensitiveResultSetDeletesAreDetected(Boolean scrollInsensitiveResultSetDeletesAreDetected)
          Sets whether or not a visible row delete can be detected by calling the method ResultSet.rowDeleted.
 void setScrollInsensitiveResultSetOthersDeletesAreVisible(Boolean scrollInsensitiveResultSetOthersDeletesAreVisible)
          Sets whether deletes made by others are visible.
 void setScrollInsensitiveResultSetOthersInsertsAreVisible(Boolean scrollInsensitiveResultSetOthersInsertsAreVisible)
          Sets whether inserts made by others are visible.
 void setScrollInsensitiveResultSetOthersUpdatesAreVisible(Boolean scrollInsensitiveResultSetOthersUpdatesAreVisible)
          Sets whether updates made by others are visible.
 void setScrollInsensitiveResultSetOwnDeletesAreVisible(Boolean scrollInsensitiveResultSetOwnDeletesAreVisible)
          Sets whether a result set's own deletes are visible.
 void setScrollInsensitiveResultSetOwnInsertsAreVisible(Boolean scrollInsensitiveResultSetOwnInsertsAreVisible)
          Sets whether a result set's own inserts are visible.
 void setScrollInsensitiveResultSetOwnUpdatesAreVisible(Boolean scrollInsensitiveResultSetOwnUpdatesAreVisible)
          Sets whether for the given type of ResultSet object, the result set's own updates are visible.
 void setScrollInsensitiveResultSetUpdatesAreDetected(Boolean scrollInsensitiveResultSetUpdatesAreDetected)
          Sets whether or not a visible row update can be detected by calling the method ResultSet.rowUpdated.
 void setScrollSensitiveResultInsertsAreDetected(Boolean scrollSensitiveResultInsertsAreDetected)
          Sets whether or not a visible row insert can be detected by calling the method ResultSet.rowInserted.
 void setScrollSensitiveResultSetDeletesAreDetected(Boolean scrollSensitiveResultSetDeletesAreDetected)
          Sets whether or not a visible row delete can be detected by calling the method ResultSet.rowDeleted.
 void setScrollSensitiveResultSetOthersDeletesAreVisible(Boolean scrollSensitiveResultSetOthersDeletesAreVisible)
          Sets whether deletes made by others are visible.
 void setScrollSensitiveResultSetOthersInsertsAreVisible(Boolean scrollSensitiveResultSetOthersInsertsAreVisible)
          Sets whether inserts made by others are visible.
 void setScrollSensitiveResultSetOthersUpdatesAreVisible(Boolean scrollSensitiveResultSetOthersUpdatesAreVisible)
          Sets whether updates made by others are visible.
 void setScrollSensitiveResultSetOwnDeletesAreVisible(Boolean scrollSensitiveResultSetOwnDeletesAreVisible)
          Sets whether a result set's own deletes are visible.
 void setScrollSensitiveResultSetOwnInsertsAreVisible(Boolean scrollSensitiveResultSetOwnInsertsAreVisible)
          Sets whether a result set's own inserts are visible.
 void setScrollSensitiveResultSetOwnUpdatesAreVisible(Boolean scrollSensitiveResultSetOwnUpdatesAreVisible)
          Sets whether for the given type of ResultSet object, the result set's own updates are visible.
 void setScrollSensitiveResultSetUpdatesAreDetected(Boolean scrollSensitiveResultSetUpdatesAreDetected)
          Sets whether or not a visible row update can be detected by calling the method ResultSet.rowUpdated.
 void setSearchStringEscape(String searchStringEscape)
          Sets the string that can be used to escape wildcard characters.
 void setSQLStateType(SQLStateType sqlStateType)
          Indicates whether the SQLSTATE returned by SQLException.getSQLState is X/Open (now known as Open Group) SQL CLI or SQL99.
 void setStoresLowerCaseIdentifiers(Boolean storesLowerCaseIdentifiers)
          sets whether this database treats mixed case unquoted SQL identifiers as case insensitive and stores them in lower case.
 void setStoresLowerCaseQuotedIdentifiers(Boolean storesLowerCaseQuotedIdentifiers)
          Sets whether this database treats mixed case quoted SQL identifiers as case insensitive and stores them in lower case.
 void setStoresMixedCaseIdentifiers(Boolean storesMixedCaseIdentifiers)
          Sets whether this database treats mixed case unquoted SQL identifiers as case insensitive and stores them in mixed case.
 void setStoresMixedCaseQuotedIdentifiers(Boolean storesMixedCaseQuotedIdentifiers)
          Sets whether this database treats mixed case quoted SQL identifiers as case insensitive and stores them in mixed case.
 void setStoresUpperCaseIdentifiers(Boolean storesUpperCaseIdentifiers)
          Sets whether this database treats mixed case unquoted SQL identifiers as case insensitive and stores them in upper case.
 void setStoresUpperCaseQuotedIdentifiers(Boolean storesUpperCaseQuotedIdentifiers)
          Sets whether this database treats mixed case quoted SQL identifiers as case insensitive and stores them in upper case.
 void setSupportsAlterTableWithAddColumn(Boolean supportsAlterTableWithAddColumn)
          Sets whether this database supports ALTER TABLE with add column.
 void setSupportsAlterTableWithDropColumn(Boolean supportsAlterTableWithDropColumn)
          Sets whether this database supports ALTER TABLE with drop column.
 void setSupportsANSI92EntryLevelSQL(Boolean supportsANSI92EntryLevelSQL)
          Sets whether this database supports the ANSI92 entry level SQL grammar.
 void setSupportsANSI92FullSQL(Boolean supportsANSI92FullSQL)
          Sets whether this database supports the ANSI92 full SQL grammar supported.
 void setSupportsANSI92IntermediateSQL(Boolean supportsANSI92IntermediateSQL)
          Sets whether this database supports the ANSI92 intermediate SQL grammar supported.
 void setSupportsBatchUpdates(Boolean supportsBatchUpdates)
          Sets whether this database supports batch updates.
 void setSupportsCatalogsInDataManipulation(Boolean supportsCatalogsInDataManipulation)
          Sets whether a catalog name can be used in a data manipulation statement.
 void setSupportsCatalogsInIndexDefinitions(Boolean supportsCatalogsInIndexDefinitions)
          Sets whether a catalog name can be used in an index definition statement.
 void setSupportsCatalogsInPrivilegeDefinitions(Boolean supportsCatalogsInPrivilegeDefinitions)
          Sets whether a catalog name can be used in a privilege definition statement.
 void setSupportsCatalogsInProcedureCalls(Boolean supportsCatalogsInProcedureCalls)
          Sets whether a catalog name can be used in a procedure call statement.
 void setSupportsCatalogsInTableDefinitions(Boolean supportsCatalogsInTableDefinitions)
          Sets whether a catalog name can be used in a table definition statement.
 void setSupportsColumnAliasing(Boolean supportsColumnAliasing)
          Sets whether this database supports column aliasing.
 void setSupportsConvert(Boolean supportsConvert)
          Sets whether this database supports the CONVERT function between SQL types.
 void setSupportsCoreSQLGrammar(Boolean supportsCoreSQLGrammar)
          Sets whether this database supports the ODBC Core SQL grammar.
 void setSupportsCorrelatedSubqueries(Boolean supportsCorrelatedSubqueries)
          Sets whether this database supports correlated subqueries.
 void setSupportsDataDefinitionAndDataManipulationTransactions(Boolean supportsDataDefinitionAndDataManipulationTransactions)
          Sets whether this database supports both data definition and data manipulation statements within a transaction.
 void setSupportsDataManipulationTransactionsOnly(Boolean supportsDataManipulationTransactionsOnly)
          Sets whether this database supports only data manipulation statements within a transaction.
 void setSupportsDifferentTableCorrelationNames(Boolean supportsDifferentTableCorrelationNames)
          Sets whether, when table correlation names are supported, they are restricted to being different from the names of the tables.
 void setSupportsExpressionsInOrderBy(Boolean supportsExpressionsInOrderBy)
          Sets whether this database supports expressions in ORDER BY lists.
 void setSupportsExtendedSQLGrammar(Boolean supportsExtendedSQLGrammar)
          Sets whether this database supports the ODBC Extended SQL grammar.
 void setSupportsFullOuterJoins(Boolean supportsFullOuterJoins)
          Sets whether this database supports full nested outer joins.
 void setSupportsGetGeneratedKeys(Boolean supportsGetGeneratedKeys)
          Sets whether auto-generated keys can be retrieved after a statement has been executed.
 void setSupportsGroupBy(Boolean supportsGroupBy)
          Sets whether this database supports some form of GROUP BY clause.
 void setSupportsGroupByBeyondSelect(Boolean supportsGroupByBeyondSelect)
          Sets whether this database supports using columns not included in the SELECT statement in a GROUP BY clause provided that all of the columns in the SELECT statement are included in the GROUP BY clause.
 void setSupportsGroupByUnrelated(Boolean supportsGroupByUnrelated)
          Sets whether this database supports using a column that is not in the SELECT statement in a GROUP BY clause.
 void setSupportsIntegrityEnhancementFacility(Boolean supportsIntegrityEnhancementFacility)
          Sets whether this database supports the SQL Integrity Enhancement Facility.
 void setSupportsLikeEscapeClause(Boolean supportsLikeEscapeClause)
          Sets whether this database supports specifying a LIKE escape clause.
 void setSupportsLimitedOuterJoins(Boolean supportsLimitedOuterJoins)
          Sets whether this database provides limited support for outer joins.
 void setSupportsMinimumSQLGrammar(Boolean supportsMinimumSQLGrammar)
          Sets whether this database supports the ODBC Minimum SQL grammar.
 void setSupportsMixedCaseIdentifiers(Boolean supportsMixedCaseIdentifiers)
          Sets whether this database treats mixed case unquoted SQL identifiers as case sensitive and as a result stores them in mixed case.
 void setSupportsMixedCaseQuotedIdentifiers(Boolean supportsMixedCaseQuotedIdentifiers)
          Sets whether this database treats mixed case quoted SQL identifiers as case sensitive and as a result stores them in mixed case.
 void setSupportsMultipleOpenResults(Boolean supportsMultipleOpenResults)
          Sets whether it is possible to have multiple ResultSet objects returned from a CallableStatement object simultaneously.
 void setSupportsMultipleResultSets(Boolean supportsMultipleResultSets)
          Sets whether this database supports getting multiple ResultSet objects from a single call to the method execute.
 void setSupportsMultipleTransactions(Boolean supportsMultipleTransactions)
          Sets whether this database allows having multiple transactions open at once (on different connections).
 void setSupportsNamedParameters(Boolean supportsNamedParameters)
          Sets whether this database supports named parameters to callable statements.
 void setSupportsNonNullableColumns(Boolean supportsNonNullableColumns)
          Sets whether columns in this database may be defined as non-nullable.
 void setSupportsOpenCursorsAcrossCommit(Boolean supportsOpenCursorsAcrossCommit)
          Sets whether this database supports keeping cursors open across commits.
 void setSupportsOpenCursorsAcrossRollback(Boolean supportsOpenCursorsAcrossRollback)
          Sets whether this database supports keeping cursors open across rollbacks.
 void setSupportsOpenStatementsAcrossCommit(Boolean supportsOpenStatementsAcrossCommit)
          sets whether this database supports keeping statements open across commits.
 void setSupportsOpenStatementsAcrossRollback(Boolean supportsOpenStatementsAcrossRollback)
          Sets whether this database supports keeping statements open across rollbacks.
 void setSupportsOrderByUnrelated(Boolean supportsOrderByUnrelated)
          Sets whether this database supports using a column that is not in the SELECT statement in an ORDER BY clause.
 void setSupportsOuterJoins(Boolean supportsOuterJoins)
          Sets whether this database supports some form of outer join.
 void setSupportsPositionedDelete(Boolean supportsPositionedDelete)
          Sets whether this database supports positioned DELETE statements.
 void setSupportsPositionedUpdate(Boolean supportsPositionedUpdate)
          Sets whether this database supports positioned UPDATE statements.
 void setSupportsResultSetCloseCurrorsAtCommitHoldability(Boolean supportsResultSetCloseCurrorsAtCommitHoldability)
          Sets whether this database supports the given result set holdability.
 void setSupportsResultSetHoldCurrorsOverCommitHoldability(Boolean supportsResultSetHoldCurrorsOverCommitHoldability)
          Sets whether this database supports the given result set holdability.
 void setSupportsSavepoints(Boolean supportsSavepoints)
          Sets whether this database supports savepoints.
 void setSupportsSchemasInDataManipulation(Boolean supportsSchemasInDataManipulation)
          Sets whether a schema name can be used in a data manipulation statement.
 void setSupportsSchemasInIndexDefinitions(Boolean supportsSchemasInIndexDefinitions)
          Sets whether a schema name can be used in an index definition statement.
 void setSupportsSchemasInPrivilegeDefinitions(Boolean supportsSchemasInPrivilegeDefinitions)
          Sets whether a schema name can be used in a privilege definition statement.
 void setSupportsSchemasInProcedureCalls(Boolean supportsSchemasInProcedureCalls)
          Sets whether a schema name can be used in a procedure call statement.
 void setSupportsSchemasInTableDefinitions(Boolean supportsSchemasInTableDefinitions)
          Sets whether a schema name can be used in a table definition statement.
 void setSupportsSelectForUpdate(Boolean supportsSelectForUpdate)
          Sets whether this database supports SELECT FOR UPDATE statements.
 void setSupportsStatementPooling(Boolean supportsStatementPooling)
          Sets whether this database supports statement pooling.
 void setSupportsStoredProcedures(Boolean supportsStoredProcedures)
          Sets whether this database supports stored procedure calls that use the stored procedure escape syntax.
 void setSupportsSubqueriesInComparisons(Boolean supportsSubqueriesInComparisons)
          Retrieves whether this database supports subqueries in comparison expressions.
 void setSupportsSubqueriesInExists(Boolean supportsSubqueriesInExists)
          Sets whether this database supports subqueries in EXISTS expressions.
 void setSupportsSubqueriesInIns(Boolean supportsSubqueriesInIns)
          Sets whether this database supports subqueries in IN statements.
 void setSupportsSubqueriesInQuantifieds(Boolean supportsSubqueriesInQuantifieds)
          Sets whether this database supports subqueries in quantified expressions.
 void setSupportsTableCorrelationNames(Boolean supportsTableCorrelationNames)
          Sets whether this database supports table correlation names.
 void setSupportsTransactions(Boolean supportsTransactions)
          Sets whether this database supports transactions.
 void setSupportsUnion(Boolean supportsUnion)
          Sets whether this database supports SQL UNION.
 void setSupportsUnionAll(Boolean supportsUnionAll)
          Sets whether this database supports SQL UNION ALL.
 void setURL(String url)
          Sets the URL for this DBMS.
 void setUserName(String userName)
          Sets the user name as known to this database.
 void setUsesLocalFilePerTable(Boolean usesLocalFilePerTable)
          Sets whether this database uses a file for each table.
 void setUsesLocalFiles(Boolean usesLocalFiles)
          Sets whether this database stores tables in a local file.
 
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Constructor Detail

DatabaseBean

public DatabaseBean()
Default constructor

Method Detail

getExceptionList

public List<DatabaseMetaDataMethodException> getExceptionList()
Returns list of failed database metadata methods through the DatabaseMetaDataMethodExceptions

Specified by:
getExceptionList in interface Database
Returns:
list of failed database metadata methods through the DatabaseMetaDataMethodExceptions

addException

public void addException(DatabaseMetaDataMethodException exception)
Adds the DatabaseMetaDataMethodException to the DatabaseMetadataProvider exception list

Specified by:
addException in interface Database
Parameters:
exception - the DatabaseMetaDataMethodException

findException

public DatabaseMetaDataMethodException findException(String methodName)
Searches the DatabaseMetaDataMethodException by method name

Specified by:
findException in interface Database
Parameters:
methodName - the name of method that caused exception
Returns:
the DatabaseMetaDataMethodException if found, otherwise returns null

isDatabaseMetaDataMethodFailed

public boolean isDatabaseMetaDataMethodFailed(String methodName)
Checks that specified database metadata method of provider is failed or not

Specified by:
isDatabaseMetaDataMethodFailed in interface Database
Parameters:
methodName - the name of method that caused exception
Returns:
true if method failed; false otherwise

getName

public String getName()
Gets database name

Specified by:
getName in interface Database
Returns:
database name

setName

public void setName(String name)
Sets database name

Specified by:
setName in interface Database
Parameters:
name - the database name

isAllProceduresAreCallable

public Boolean isAllProceduresAreCallable()
Retrieves whether the current user can call all the procedures returned by the method DatabaseMetaData.getProcedures.

Specified by:
isAllProceduresAreCallable in interface Database
Returns:
true if so; false otherwise

setAllProceduresAreCallable

public void setAllProceduresAreCallable(Boolean allProceduresAreCallable)
sets whether the current user can call all the procedures returned by the method DatabaseMetaData.getProcedures.

Specified by:
setAllProceduresAreCallable in interface Database
Parameters:
allProceduresAreCallable - true if so; false otherwise

isAllTablesAreSelectable

public Boolean isAllTablesAreSelectable()
Retrieves whether the current user can use all the tables returned by the method DatabaseMetaData.getTables in a SELECT statement.

Specified by:
isAllTablesAreSelectable in interface Database
Returns:
true if so; false otherwise

setAllTablesAreSelectable

public void setAllTablesAreSelectable(Boolean allTablesAreSelectable)
Sets whether the current user can use all the tables returned by the method DatabaseMetaData.getTables in a SELECT statement.

Specified by:
setAllTablesAreSelectable in interface Database
Parameters:
allTablesAreSelectable - true if so; false otherwise

getURL

public String getURL()
Retrieves the URL for this DBMS.

Specified by:
getURL in interface Database
Returns:
the URL for this DBMS or null if it cannot be generated

setURL

public void setURL(String url)
Sets the URL for this DBMS.

Specified by:
setURL in interface Database
Parameters:
url - the URL for this DBMS or null if it cannot be generated

getUserName

public String getUserName()
Retrieves the user name as known to this database.

Specified by:
getUserName in interface Database
Returns:
the database user name

setUserName

public void setUserName(String userName)
Sets the user name as known to this database.

Specified by:
setUserName in interface Database
Parameters:
userName - the database user name

isReadOnly

public Boolean isReadOnly()
Retrieves whether this database is in read-only mode.

Specified by:
isReadOnly in interface Database
Returns:
true if so; false otherwise

setReadOnly

public void setReadOnly(Boolean readOnly)
Sets whether this database is in read-only mode.

Specified by:
setReadOnly in interface Database
Parameters:
readOnly - true if so; false otherwise

isNullsAreSortedHigh

public Boolean isNullsAreSortedHigh()
Retrieves whether NULL values are sorted high. Sorted high means that NULL values sort higher than any other value in a domain. In an ascending order, if this method returns true, NULL values will appear at the end. By contrast, the method DatabaseMetaData.nullsAreSortedAtEnd indicates whether NULL values are sorted at the end regardless of sort order.

Specified by:
isNullsAreSortedHigh in interface Database
Returns:
true if so; false otherwise

setNullsAreSortedHigh

public void setNullsAreSortedHigh(Boolean nullsAreSortedHigh)
Sets whether NULL values are sorted high. Sorted high means that NULL values sort higher than any other value in a domain. In an ascending order, if this method returns true, NULL values will appear at the end. By contrast, the method DatabaseMetaData.nullsAreSortedAtEnd indicates whether NULL values are sorted at the end regardless of sort order.

Specified by:
setNullsAreSortedHigh in interface Database
Parameters:
nullsAreSortedHigh - true if so; false otherwise

isNullsAreSortedLow

public Boolean isNullsAreSortedLow()
Retrieves whether NULL values are sorted low. Sorted low means that NULL values sort lower than any other value in a domain. In an ascending order, if this method returns true, NULL values will appear at the beginning. By contrast, the method DatabaseMetaData.nullsAreSortedAtStart indicates whether NULL values are sorted at the beginning regardless of sort order.

Specified by:
isNullsAreSortedLow in interface Database
Returns:
true if so; false otherwise

setNullsAreSortedLow

public void setNullsAreSortedLow(Boolean nullsAreSortedLow)
Sets whether NULL values are sorted low. Sorted low means that NULL values sort lower than any other value in a domain. In an ascending order, if this method returns true, NULL values will appear at the beginning. By contrast, the method DatabaseMetaData.nullsAreSortedAtStart indicates whether NULL values are sorted at the beginning regardless of sort order.

Specified by:
setNullsAreSortedLow in interface Database
Parameters:
nullsAreSortedLow - true if so; false otherwise

isNullsAreSortedAtStart

public Boolean isNullsAreSortedAtStart()
Retrieves whether NULL values are sorted at the start regardless of sort order.

Specified by:
isNullsAreSortedAtStart in interface Database
Returns:
true if so; false otherwise

setNullsAreSortedAtStart

public void setNullsAreSortedAtStart(Boolean nullsAreSortedAtStart)
Sets whether NULL values are sorted at the start regardless of sort order.

Specified by:
setNullsAreSortedAtStart in interface Database
Parameters:
nullsAreSortedAtStart - true if so; false otherwise

isNullsAreSortedAtEnd

public Boolean isNullsAreSortedAtEnd()
Retrieves whether NULL values are sorted at the end regardless of sort order.

Specified by:
isNullsAreSortedAtEnd in interface Database
Returns:
true if so; false otherwise

setNullsAreSortedAtEnd

public void setNullsAreSortedAtEnd(Boolean nullsAreSortedAtEnd)
Sets whether NULL values are sorted at the end regardless of sort order.

Specified by:
setNullsAreSortedAtEnd in interface Database
Parameters:
nullsAreSortedAtEnd - true if so; false otherwise

getDatabaseProductName

public String getDatabaseProductName()
Retrieves the name of this database product.

Specified by:
getDatabaseProductName in interface Database
Returns:
database product name

setDatabaseProductName

public void setDatabaseProductName(String databaseProductName)
Sets the name of this database product.

Specified by:
setDatabaseProductName in interface Database
Parameters:
databaseProductName - database product name

getDatabaseProductVersion

public String getDatabaseProductVersion()
Retrieves the version number of this database product.

Specified by:
getDatabaseProductVersion in interface Database
Returns:
database version number

setDatabaseProductVersion

public void setDatabaseProductVersion(String databaseProductVersion)
Sets the version number of this database product.

Specified by:
setDatabaseProductVersion in interface Database
Parameters:
databaseProductVersion - database version number

getDriverName

public String getDriverName()
Retrieves the name of this JDBC driver.

Specified by:
getDriverName in interface Database
Returns:
JDBC driver name

setDriverName

public void setDriverName(String driverName)
Sets the name of this JDBC driver.

Specified by:
setDriverName in interface Database
Parameters:
driverName - JDBC driver name

getDriverVersion

public String getDriverVersion()
Retrieves the version number of this JDBC driver as a String.

Specified by:
getDriverVersion in interface Database
Returns:
JDBC driver version

setDriverVersion

public void setDriverVersion(String driverVersion)
Sets the version number of this JDBC driver as a String.

Specified by:
setDriverVersion in interface Database
Parameters:
driverVersion - the JDBC driver version

getDriverMajorVersion

public Integer getDriverMajorVersion()
Retrieves this JDBC driver's minor version number.

Specified by:
getDriverMajorVersion in interface Database
Returns:
JDBC driver minor version number

setDriverMajorVersion

public void setDriverMajorVersion(Integer driverMajorVersion)
Sets this JDBC driver's major version number.

Specified by:
setDriverMajorVersion in interface Database
Parameters:
driverMajorVersion - the JDBC driver major version

getDriverMinorVersion

public Integer getDriverMinorVersion()
Retrieves this JDBC driver's minor version number.

Specified by:
getDriverMinorVersion in interface Database
Returns:
JDBC driver minor version number

setDriverMinorVersion

public void setDriverMinorVersion(Integer driverMinorVersion)
Sets this JDBC driver's minor version number.

Specified by:
setDriverMinorVersion in interface Database
Parameters:
driverMinorVersion - the JDBC driver minor version number

isUsesLocalFiles

public Boolean isUsesLocalFiles()
Retrieves whether this database stores tables in a local file.

Specified by:
isUsesLocalFiles in interface Database
Returns:
true if so; false otherwise

setUsesLocalFiles

public void setUsesLocalFiles(Boolean usesLocalFiles)
Sets whether this database stores tables in a local file.

Specified by:
setUsesLocalFiles in interface Database
Parameters:
usesLocalFiles - true if so; false otherwise

isUsesLocalFilePerTable

public Boolean isUsesLocalFilePerTable()
Retrieves whether this database uses a file for each table.

Specified by:
isUsesLocalFilePerTable in interface Database
Returns:
true if this database uses a local file for each table; false otherwise

setUsesLocalFilePerTable

public void setUsesLocalFilePerTable(Boolean usesLocalFilePerTable)
Sets whether this database uses a file for each table.

Specified by:
setUsesLocalFilePerTable in interface Database
Parameters:
usesLocalFilePerTable - true if this database uses a local file for each table; false otherwise

isSupportsMixedCaseIdentifiers

public Boolean isSupportsMixedCaseIdentifiers()
Retrieves whether this database treats mixed case unquoted SQL identifiers as case sensitive and as a result stores them in mixed case.

Specified by:
isSupportsMixedCaseIdentifiers in interface Database
Returns:
true if so; false otherwise

setSupportsMixedCaseIdentifiers

public void setSupportsMixedCaseIdentifiers(Boolean supportsMixedCaseIdentifiers)
Sets whether this database treats mixed case unquoted SQL identifiers as case sensitive and as a result stores them in mixed case.

Specified by:
setSupportsMixedCaseIdentifiers in interface Database
Parameters:
supportsMixedCaseIdentifiers - true if so; false otherwise

isStoresUpperCaseIdentifiers

public Boolean isStoresUpperCaseIdentifiers()
Retrieves whether this database treats mixed case unquoted SQL identifiers as case insensitive and stores them in upper case.

Specified by:
isStoresUpperCaseIdentifiers in interface Database
Returns:
true if so; false otherwise

setStoresUpperCaseIdentifiers

public void setStoresUpperCaseIdentifiers(Boolean storesUpperCaseIdentifiers)
Sets whether this database treats mixed case unquoted SQL identifiers as case insensitive and stores them in upper case.

Specified by:
setStoresUpperCaseIdentifiers in interface Database
Parameters:
storesUpperCaseIdentifiers - true if so; false otherwise

isStoresLowerCaseIdentifiers

public Boolean isStoresLowerCaseIdentifiers()
Retrieves whether this database treats mixed case unquoted SQL identifiers as case insensitive and stores them in lower case.

Specified by:
isStoresLowerCaseIdentifiers in interface Database
Returns:
true if so; false otherwise

setStoresLowerCaseIdentifiers

public void setStoresLowerCaseIdentifiers(Boolean storesLowerCaseIdentifiers)
sets whether this database treats mixed case unquoted SQL identifiers as case insensitive and stores them in lower case.

Specified by:
setStoresLowerCaseIdentifiers in interface Database
Parameters:
storesLowerCaseIdentifiers - true if so; false otherwise

isStoresMixedCaseIdentifiers

public Boolean isStoresMixedCaseIdentifiers()
Retrieves whether this database treats mixed case unquoted SQL identifiers as case insensitive and stores them in mixed case.

Specified by:
isStoresMixedCaseIdentifiers in interface Database
Returns:
true if so; false otherwise

setStoresMixedCaseIdentifiers

public void setStoresMixedCaseIdentifiers(Boolean storesMixedCaseIdentifiers)
Sets whether this database treats mixed case unquoted SQL identifiers as case insensitive and stores them in mixed case.

Specified by:
setStoresMixedCaseIdentifiers in interface Database
Parameters:
storesMixedCaseIdentifiers - true if so; false otherwise

isSupportsMixedCaseQuotedIdentifiers

public Boolean isSupportsMixedCaseQuotedIdentifiers()
Retrieves whether this database treats mixed case quoted SQL identifiers as case sensitive and as a result stores them in mixed case.

Specified by:
isSupportsMixedCaseQuotedIdentifiers in interface Database
Returns:
true if so; false otherwise

setSupportsMixedCaseQuotedIdentifiers

public void setSupportsMixedCaseQuotedIdentifiers(Boolean supportsMixedCaseQuotedIdentifiers)
Sets whether this database treats mixed case quoted SQL identifiers as case sensitive and as a result stores them in mixed case.

Specified by:
setSupportsMixedCaseQuotedIdentifiers in interface Database
Parameters:
supportsMixedCaseQuotedIdentifiers - true if so; false otherwise

isStoresUpperCaseQuotedIdentifiers

public Boolean isStoresUpperCaseQuotedIdentifiers()
Retrieves whether this database treats mixed case quoted SQL identifiers as case insensitive and stores them in upper case.

Specified by:
isStoresUpperCaseQuotedIdentifiers in interface Database
Returns:
true if so; false otherwise

setStoresUpperCaseQuotedIdentifiers

public void setStoresUpperCaseQuotedIdentifiers(Boolean storesUpperCaseQuotedIdentifiers)
Sets whether this database treats mixed case quoted SQL identifiers as case insensitive and stores them in upper case.

Specified by:
setStoresUpperCaseQuotedIdentifiers in interface Database
Parameters:
storesUpperCaseQuotedIdentifiers - true if so; false otherwise

isStoresLowerCaseQuotedIdentifiers

public Boolean isStoresLowerCaseQuotedIdentifiers()
Retrieves whether this database treats mixed case quoted SQL identifiers as case insensitive and stores them in lower case.

Specified by:
isStoresLowerCaseQuotedIdentifiers in interface Database
Returns:
true if so; false otherwise

setStoresLowerCaseQuotedIdentifiers

public void setStoresLowerCaseQuotedIdentifiers(Boolean storesLowerCaseQuotedIdentifiers)
Sets whether this database treats mixed case quoted SQL identifiers as case insensitive and stores them in lower case.

Specified by:
setStoresLowerCaseQuotedIdentifiers in interface Database
Parameters:
storesLowerCaseQuotedIdentifiers - true if so; false otherwise

isStoresMixedCaseQuotedIdentifiers

public Boolean isStoresMixedCaseQuotedIdentifiers()
Retrieves whether this database treats mixed case quoted SQL identifiers as case insensitive and stores them in mixed case.

Specified by:
isStoresMixedCaseQuotedIdentifiers in interface Database
Returns:
true if so; false otherwise

setStoresMixedCaseQuotedIdentifiers

public void setStoresMixedCaseQuotedIdentifiers(Boolean storesMixedCaseQuotedIdentifiers)
Sets whether this database treats mixed case quoted SQL identifiers as case insensitive and stores them in mixed case.

Specified by:
setStoresMixedCaseQuotedIdentifiers in interface Database
Parameters:
storesMixedCaseQuotedIdentifiers - true if so; false otherwise

getIdentifierQuoteString

public String getIdentifierQuoteString()
Retrieves the string used to quote SQL identifiers. This method returns a space " " if identifier quoting is not supported.

Specified by:
getIdentifierQuoteString in interface Database
Returns:
the quoting string or a space if quoting is not supported

setIdentifierQuoteString

public void setIdentifierQuoteString(String identifierQuoteString)
Sets the string used to quote SQL identifiers. This method returns a space " " if identifier quoting is not supported.

Specified by:
setIdentifierQuoteString in interface Database
Parameters:
identifierQuoteString - the quoting string or a space if quoting is not supported

getSQLKeywords

public Set<String> getSQLKeywords()
Retrieves a list of all of this database's SQL keywords that are NOT also SQL92 keywords.

Specified by:
getSQLKeywords in interface Database
Returns:
the list of this database's keywords that are not also SQL92 keywords

addSQLKeyword

public void addSQLKeyword(String sqlKeyword)
Adds SQL keyword

Specified by:
addSQLKeyword in interface Database
Parameters:
sqlKeyword - the SQL keyword to add

deleteSQLKeyword

public void deleteSQLKeyword(String sqlKeyword)
Deletes SQL keyword

Specified by:
deleteSQLKeyword in interface Database
Parameters:
sqlKeyword - the SQL keyword to delete

isSQLKeywordSupported

public Boolean isSQLKeywordSupported(String sqlKeyword)
Is SQL keyword supported

Specified by:
isSQLKeywordSupported in interface Database
Parameters:
sqlKeyword - the SQL keyword to search
Returns:
true if supported; false otherwiose

getNumericFunctions

public Set<String> getNumericFunctions()
Retrieves a list of math functions available with this database. These are the Open /Open CLI math function names used in the JDBC function escape clause.

Specified by:
getNumericFunctions in interface Database
Returns:
the list of math functions supported by this database

addNumericFunction

public void addNumericFunction(String functionName)
Adds numeric function

Specified by:
addNumericFunction in interface Database
Parameters:
functionName - the name of numeric function to add

deleteNumericFunction

public void deleteNumericFunction(String functionName)
Deletes numeric function

Specified by:
deleteNumericFunction in interface Database
Parameters:
functionName - the name of numeric function to delete

isNumericFunctionSupported

public Boolean isNumericFunctionSupported(String functionName)
Is Numeric function supported

Specified by:
isNumericFunctionSupported in interface Database
Parameters:
functionName - the name of numeric function
Returns:
true is supported; false otherwise

getStringFunctions

public Set<String> getStringFunctions()
Retrieves a list of string functions available with this database. These are the Open Group CLI string function names used in the JDBC function escape clause.

Specified by:
getStringFunctions in interface Database
Returns:
the list of string functions supported by this database

addStringFunction

public void addStringFunction(String functionName)
Adds String function

Specified by:
addStringFunction in interface Database
Parameters:
functionName - the name of String function to add

deleteStringFunction

public void deleteStringFunction(String functionName)
Deletes String function

Specified by:
deleteStringFunction in interface Database
Parameters:
functionName - the name of String function to delete

isStringFunctionSupported

public Boolean isStringFunctionSupported(String functionName)
Is String function supported

Specified by:
isStringFunctionSupported in interface Database
Parameters:
functionName - the name of String function
Returns:
true is supported; false otherwise

getSystemFunctions

public Set<String> getSystemFunctions()
Retrieves a list of system functions available with this database. These are the Open Group CLI system function names used in the JDBC function escape clause.

Specified by:
getSystemFunctions in interface Database
Returns:
a list of system functions supported by this database

addSystemFunction

public void addSystemFunction(String functionName)
Adds System function

Specified by:
addSystemFunction in interface Database
Parameters:
functionName - the name of System function to add

deleteSystemFunction

public void deleteSystemFunction(String functionName)
deletes System function

Specified by:
deleteSystemFunction in interface Database
Parameters:
functionName - the name of System function to delete

isSystemFunctionSupported

public Boolean isSystemFunctionSupported(String functionName)
Is System function supported

Specified by:
isSystemFunctionSupported in interface Database
Parameters:
functionName - the name of System function
Returns:
true is supported; false otherwise

getTimeDateFunctions

public Set<String> getTimeDateFunctions()
Retrieves a list of the time and date functions available with this database.

Specified by:
getTimeDateFunctions in interface Database
Returns:
the list of time and date functions supported by this database

addTimeDateFunction

public void addTimeDateFunction(String functionName)
Adds Time/Date function

Specified by:
addTimeDateFunction in interface Database
Parameters:
functionName - the name of Time/Date function to add

deleteTimeDateFunction

public void deleteTimeDateFunction(String functionName)
deletes Time/Date function

Specified by:
deleteTimeDateFunction in interface Database
Parameters:
functionName - the name of Time/Date function to delete

isTimeDateFunctionSupported

public Boolean isTimeDateFunctionSupported(String functionName)
Is Time/Date function supported

Specified by:
isTimeDateFunctionSupported in interface Database
Parameters:
functionName - the name of Time/Date function
Returns:
true is supported; false otherwise

getSearchStringEscape

public String getSearchStringEscape()
Retrieves the string that can be used to escape wildcard characters. This is the string that can be used to escape '_' or '%' in the catalog search parameters that are a pattern (and therefore use one of the wildcard characters).

The '_' character represents any single character; the '%' character represents any sequence of zero or more characters.

Specified by:
getSearchStringEscape in interface Database
Returns:
the string used to escape wildcard characters

setSearchStringEscape

public void setSearchStringEscape(String searchStringEscape)
Sets the string that can be used to escape wildcard characters. This is the string that can be used to escape '_' or '%' in the catalog search parameters that are a pattern (and therefore use one of the wildcard characters).

The '_' character represents any single character; the '%' character represents any sequence of zero or more characters.

Specified by:
setSearchStringEscape in interface Database
Parameters:
searchStringEscape - the string used to escape wildcard characters

getExtraNameCharacters

public String getExtraNameCharacters()
Retrieves all the "extra" characters that can be used in unquoted identifier names (those beyond a-z, A-Z, 0-9 and _).

Specified by:
getExtraNameCharacters in interface Database
Returns:
the string containing the extra characters

setExtraNameCharacters

public void setExtraNameCharacters(String extraNameCharacters)
Sets all the "extra" characters that can be used in unquoted identifier names (those beyond a-z, A-Z, 0-9 and _).

Specified by:
setExtraNameCharacters in interface Database
Parameters:
extraNameCharacters - the string containing the extra characters

isSupportsAlterTableWithAddColumn

public Boolean isSupportsAlterTableWithAddColumn()
Retrieves whether this database supports ALTER TABLE with add column.

Specified by:
isSupportsAlterTableWithAddColumn in interface Database
Returns:
true if so; false otherwise

setSupportsAlterTableWithAddColumn

public void setSupportsAlterTableWithAddColumn(Boolean supportsAlterTableWithAddColumn)
Sets whether this database supports ALTER TABLE with add column.

Specified by:
setSupportsAlterTableWithAddColumn in interface Database
Parameters:
supportsAlterTableWithAddColumn - true if so; false otherwise

isSupportsAlterTableWithDropColumn

public Boolean isSupportsAlterTableWithDropColumn()
Retrieves whether this database supports ALTER TABLE with drop column.

Specified by:
isSupportsAlterTableWithDropColumn in interface Database
Returns:
true if so; false otherwise

setSupportsAlterTableWithDropColumn

public void setSupportsAlterTableWithDropColumn(Boolean supportsAlterTableWithDropColumn)
Sets whether this database supports ALTER TABLE with drop column.

Specified by:
setSupportsAlterTableWithDropColumn in interface Database
Parameters:
supportsAlterTableWithDropColumn - true if so; false otherwise

isSupportsColumnAliasing

public Boolean isSupportsColumnAliasing()
Retrieves whether this database supports column aliasing.

If so, the SQL AS clause can be used to provide names for computed columns or to provide alias names for columns as required.

Specified by:
isSupportsColumnAliasing in interface Database
Returns:
true if so; false otherwise

setSupportsColumnAliasing

public void setSupportsColumnAliasing(Boolean supportsColumnAliasing)
Sets whether this database supports column aliasing.

If so, the SQL AS clause can be used to provide names for computed columns or to provide alias names for columns as required.

Specified by:
setSupportsColumnAliasing in interface Database
Parameters:
supportsColumnAliasing - true if so; false otherwise

isNullPlusNonNullIsNull

public Boolean isNullPlusNonNullIsNull()
Retrieves whether this database supports concatenations between NULL and non-NULL values being NULL.

Specified by:
isNullPlusNonNullIsNull in interface Database
Returns:
true if so; false otherwise

setNullPlusNonNullIsNull

public void setNullPlusNonNullIsNull(Boolean nullPlusNonNullIsNull)
Sets whether this database supports concatenations between NULL and non-NULL values being NULL.

Specified by:
setNullPlusNonNullIsNull in interface Database
Parameters:
nullPlusNonNullIsNull - true if so

isSupportsConvert

public Boolean isSupportsConvert()
Retrieves whether this database supports the CONVERT function between SQL types.

Specified by:
isSupportsConvert in interface Database
Returns:
true if so; false otherwise

setSupportsConvert

public void setSupportsConvert(Boolean supportsConvert)
Sets whether this database supports the CONVERT function between SQL types.

Specified by:
setSupportsConvert in interface Database
Parameters:
supportsConvert - true if so; false otherwise

getSupportedConversions

public Set<SqlTypeConversionPair> getSupportedConversions()
Retrieves whether this database supports the CONVERT for given SQL types. It uses original DatabaseMetaData.supportsConvert to check common (NOT ALL POSSIBLE) conversions.

Specified by:
getSupportedConversions in interface Database
Returns:
list of common (NOT ALL POSSIBLE) conversions.
See Also:
Types

addSqlTypeConversionPair

public void addSqlTypeConversionPair(SqlTypeConversionPair sqlTypeConversionPair)
Adds SqlTypeConversionPair

Specified by:
addSqlTypeConversionPair in interface Database
Parameters:
sqlTypeConversionPair - the SqlTypeConversionPair

deleteSqlTypeConversionPair

public void deleteSqlTypeConversionPair(SqlTypeConversionPair sqlTypeConversionPair)
deletes SqlTypeConversionPair

Specified by:
deleteSqlTypeConversionPair in interface Database
Parameters:
sqlTypeConversionPair - the SqlTypeConversionPair

findSqlTypeConversionPairBySrcType

public Set<SqlTypeConversionPair> findSqlTypeConversionPairBySrcType(String srcType)
Searches set of SqlTypeConversionPair by SrcType

Specified by:
findSqlTypeConversionPairBySrcType in interface Database
Parameters:
srcType -
Returns:
set of SqlTypeConversionPair

isSupportsTableCorrelationNames

public Boolean isSupportsTableCorrelationNames()
Retrieves whether this database supports table correlation names.

Specified by:
isSupportsTableCorrelationNames in interface Database
Returns:
true if so; false otherwise

setSupportsTableCorrelationNames

public void setSupportsTableCorrelationNames(Boolean supportsTableCorrelationNames)
Sets whether this database supports table correlation names.

Specified by:
setSupportsTableCorrelationNames in interface Database
Parameters:
supportsTableCorrelationNames - true if so; false otherwise

isSupportsDifferentTableCorrelationNames

public Boolean isSupportsDifferentTableCorrelationNames()
Retrieves whether, when table correlation names are supported, they are restricted to being different from the names of the tables.

Specified by:
isSupportsDifferentTableCorrelationNames in interface Database
Returns:
true if so; false otherwise

setSupportsDifferentTableCorrelationNames

public void setSupportsDifferentTableCorrelationNames(Boolean supportsDifferentTableCorrelationNames)
Sets whether, when table correlation names are supported, they are restricted to being different from the names of the tables.

Specified by:
setSupportsDifferentTableCorrelationNames in interface Database
Parameters:
supportsDifferentTableCorrelationNames - true if so; false otherwise

isSupportsExpressionsInOrderBy

public Boolean isSupportsExpressionsInOrderBy()
Retrieves whether this database supports expressions in ORDER BY lists.

Specified by:
isSupportsExpressionsInOrderBy in interface Database
Returns:
true if so; false otherwise

setSupportsExpressionsInOrderBy

public void setSupportsExpressionsInOrderBy(Boolean supportsExpressionsInOrderBy)
Sets whether this database supports expressions in ORDER BY lists.

Specified by:
setSupportsExpressionsInOrderBy in interface Database
Parameters:
supportsExpressionsInOrderBy - true if so; false otherwise

isSupportsOrderByUnrelated

public Boolean isSupportsOrderByUnrelated()
Retrieves whether this database supports using a column that is not in the SELECT statement in an ORDER BY clause.

Specified by:
isSupportsOrderByUnrelated in interface Database
Returns:
true if so; false otherwise

setSupportsOrderByUnrelated

public void setSupportsOrderByUnrelated(Boolean supportsOrderByUnrelated)
Sets whether this database supports using a column that is not in the SELECT statement in an ORDER BY clause.

Specified by:
setSupportsOrderByUnrelated in interface Database
Parameters:
supportsOrderByUnrelated - true if so

isSupportsGroupBy

public Boolean isSupportsGroupBy()
Retrieves whether this database supports some form of GROUP BY clause.

Specified by:
isSupportsGroupBy in interface Database
Returns:
true if so; false otherwise

setSupportsGroupBy

public void setSupportsGroupBy(Boolean supportsGroupBy)
Sets whether this database supports some form of GROUP BY clause.

Specified by:
setSupportsGroupBy in interface Database
Parameters:
supportsGroupBy - true if so; false otherwise

isSupportsGroupByUnrelated

public Boolean isSupportsGroupByUnrelated()
Retrieves whether this database supports using a column that is not in the SELECT statement in a GROUP BY clause.

Specified by:
isSupportsGroupByUnrelated in interface Database
Returns:
true if so; false otherwise

setSupportsGroupByUnrelated

public void setSupportsGroupByUnrelated(Boolean supportsGroupByUnrelated)
Sets whether this database supports using a column that is not in the SELECT statement in a GROUP BY clause.

Specified by:
setSupportsGroupByUnrelated in interface Database
Parameters:
supportsGroupByUnrelated - true if so; false otherwise

isSupportsGroupByBeyondSelect

public Boolean isSupportsGroupByBeyondSelect()
Retrieves whether this database supports using columns not included in the SELECT statement in a GROUP BY clause provided that all of the columns in the SELECT statement are included in the GROUP BY clause.

Specified by:
isSupportsGroupByBeyondSelect in interface Database
Returns:
true if so; false otherwise

setSupportsGroupByBeyondSelect

public void setSupportsGroupByBeyondSelect(Boolean supportsGroupByBeyondSelect)
Sets whether this database supports using columns not included in the SELECT statement in a GROUP BY clause provided that all of the columns in the SELECT statement are included in the GROUP BY clause.

Specified by:
setSupportsGroupByBeyondSelect in interface Database
Parameters:
supportsGroupByBeyondSelect - true if so; false otherwise

isSupportsLikeEscapeClause

public Boolean isSupportsLikeEscapeClause()
Retrieves whether this database supports specifying a LIKE escape clause.

Specified by:
isSupportsLikeEscapeClause in interface Database
Returns:
true if so; false otherwise

setSupportsLikeEscapeClause

public void setSupportsLikeEscapeClause(Boolean supportsLikeEscapeClause)
Sets whether this database supports specifying a LIKE escape clause.

Specified by:
setSupportsLikeEscapeClause in interface Database
Parameters:
supportsLikeEscapeClause - true if so; false otherwise

isSupportsMultipleResultSets

public Boolean isSupportsMultipleResultSets()
Retrieves whether this database supports getting multiple ResultSet objects from a single call to the method execute.

Specified by:
isSupportsMultipleResultSets in interface Database
Returns:
true if so; false otherwise

setSupportsMultipleResultSets

public void setSupportsMultipleResultSets(Boolean supportsMultipleResultSets)
Sets whether this database supports getting multiple ResultSet objects from a single call to the method execute.

Specified by:
setSupportsMultipleResultSets in interface Database
Parameters:
supportsMultipleResultSets - true if so; false otherwise

isSupportsMultipleTransactions

public Boolean isSupportsMultipleTransactions()
Retrieves whether this database allows having multiple transactions open at once (on different connections).

Specified by:
isSupportsMultipleTransactions in interface Database
Returns:
true if so; false otherwise

setSupportsMultipleTransactions

public void setSupportsMultipleTransactions(Boolean supportsMultipleTransactions)
Sets whether this database allows having multiple transactions open at once (on different connections).

Specified by:
setSupportsMultipleTransactions in interface Database
Parameters:
supportsMultipleTransactions - true if so; false otherwise

isSupportsNonNullableColumns

public Boolean isSupportsNonNullableColumns()
Retrieves whether columns in this database may be defined as non-nullable.

Specified by:
isSupportsNonNullableColumns in interface Database
Returns:
true if so; false otherwise

setSupportsNonNullableColumns

public void setSupportsNonNullableColumns(Boolean supportsNonNullableColumns)
Sets whether columns in this database may be defined as non-nullable.

Specified by:
setSupportsNonNullableColumns in interface Database
Parameters:
supportsNonNullableColumns - true if so; false otherwise

isSupportsMinimumSQLGrammar

public Boolean isSupportsMinimumSQLGrammar()
Retrieves whether this database supports the ODBC Minimum SQL grammar.

Specified by:
isSupportsMinimumSQLGrammar in interface Database
Returns:
true if so; false otherwise

setSupportsMinimumSQLGrammar

public void setSupportsMinimumSQLGrammar(Boolean supportsMinimumSQLGrammar)
Sets whether this database supports the ODBC Minimum SQL grammar.

Specified by:
setSupportsMinimumSQLGrammar in interface Database
Parameters:
supportsMinimumSQLGrammar - true if so; false otherwise

isSupportsCoreSQLGrammar

public Boolean isSupportsCoreSQLGrammar()
Retrieves whether this database supports the ODBC Core SQL grammar.

Specified by:
isSupportsCoreSQLGrammar in interface Database
Returns:
true if so; false otherwise

setSupportsCoreSQLGrammar

public void setSupportsCoreSQLGrammar(Boolean supportsCoreSQLGrammar)
Sets whether this database supports the ODBC Core SQL grammar.

Specified by:
setSupportsCoreSQLGrammar in interface Database
Parameters:
supportsCoreSQLGrammar - true if so; false otherwise

isSupportsExtendedSQLGrammar

public Boolean isSupportsExtendedSQLGrammar()
Retrieves whether this database supports the ODBC Extended SQL grammar.

Specified by:
isSupportsExtendedSQLGrammar in interface Database
Returns:
true if so; false otherwise

setSupportsExtendedSQLGrammar

public void setSupportsExtendedSQLGrammar(Boolean supportsExtendedSQLGrammar)
Sets whether this database supports the ODBC Extended SQL grammar.

Specified by:
setSupportsExtendedSQLGrammar in interface Database
Parameters:
supportsExtendedSQLGrammar - true if so; false otherwise

isSupportsANSI92EntryLevelSQL

public Boolean isSupportsANSI92EntryLevelSQL()
Retrieves whether this database supports the ANSI92 entry level SQL grammar.

Specified by:
isSupportsANSI92EntryLevelSQL in interface Database
Returns:
true if so; false otherwise

setSupportsANSI92EntryLevelSQL

public void setSupportsANSI92EntryLevelSQL(Boolean supportsANSI92EntryLevelSQL)
Sets whether this database supports the ANSI92 entry level SQL grammar.

Specified by:
setSupportsANSI92EntryLevelSQL in interface Database
Parameters:
supportsANSI92EntryLevelSQL - true if so; false otherwise

isSupportsANSI92IntermediateSQL

public Boolean isSupportsANSI92IntermediateSQL()
Retrieves whether this database supports the ANSI92 intermediate SQL grammar supported.

Specified by:
isSupportsANSI92IntermediateSQL in interface Database
Returns:
true if so; false otherwise

setSupportsANSI92IntermediateSQL

public void setSupportsANSI92IntermediateSQL(Boolean supportsANSI92IntermediateSQL)
Sets whether this database supports the ANSI92 intermediate SQL grammar supported.

Specified by:
setSupportsANSI92IntermediateSQL in interface Database
Parameters:
supportsANSI92IntermediateSQL - true if so; false otherwise

isSupportsANSI92FullSQL

public Boolean isSupportsANSI92FullSQL()
Retrieves whether this database supports the ANSI92 full SQL grammar supported.

Specified by:
isSupportsANSI92FullSQL in interface Database
Returns:
true if so; false otherwise

setSupportsANSI92FullSQL

public void setSupportsANSI92FullSQL(Boolean supportsANSI92FullSQL)
Sets whether this database supports the ANSI92 full SQL grammar supported.

Specified by:
setSupportsANSI92FullSQL in interface Database
Parameters:
supportsANSI92FullSQL - true if so; false otherwise

isSupportsIntegrityEnhancementFacility

public Boolean isSupportsIntegrityEnhancementFacility()
Retrieves whether this database supports the SQL Integrity Enhancement Facility.

Specified by:
isSupportsIntegrityEnhancementFacility in interface Database
Returns:
true if so; false otherwise

setSupportsIntegrityEnhancementFacility

public void setSupportsIntegrityEnhancementFacility(Boolean supportsIntegrityEnhancementFacility)
Sets whether this database supports the SQL Integrity Enhancement Facility.

Specified by:
setSupportsIntegrityEnhancementFacility in interface Database
Parameters:
supportsIntegrityEnhancementFacility - true if so; false otherwise

isSupportsOuterJoins

public Boolean isSupportsOuterJoins()
Retrieves whether this database supports some form of outer join.

Specified by:
isSupportsOuterJoins in interface Database
Returns:
true if so; false otherwise

setSupportsOuterJoins

public void setSupportsOuterJoins(Boolean supportsOuterJoins)
Sets whether this database supports some form of outer join.

Specified by:
setSupportsOuterJoins in interface Database
Parameters:
supportsOuterJoins - true if so; false otherwise

isSupportsFullOuterJoins

public Boolean isSupportsFullOuterJoins()
Retrieves whether this database supports full nested outer joins.

Specified by:
isSupportsFullOuterJoins in interface Database
Returns:
true if so; false otherwise

setSupportsFullOuterJoins

public void setSupportsFullOuterJoins(Boolean supportsFullOuterJoins)
Sets whether this database supports full nested outer joins.

Specified by:
setSupportsFullOuterJoins in interface Database
Parameters:
supportsFullOuterJoins - true if so; false otherwise

isSupportsLimitedOuterJoins

public Boolean isSupportsLimitedOuterJoins()
Retrieves whether this database provides limited support for outer joins. (This will be true if the method DatabaseMetaData.supportsFullOuterJoins returns true).

Specified by:
isSupportsLimitedOuterJoins in interface Database
Returns:
true if so; false otherwise

setSupportsLimitedOuterJoins

public void setSupportsLimitedOuterJoins(Boolean supportsLimitedOuterJoins)
Sets whether this database provides limited support for outer joins. (This will be true if the method DatabaseMetaData.supportsFullOuterJoins returns true).

Specified by:
setSupportsLimitedOuterJoins in interface Database
Parameters:
supportsLimitedOuterJoins - true if so; false otherwise

getSchemaTerm

public String getSchemaTerm()
Retrieves the database vendor's preferred term for "schema".

Specified by:
getSchemaTerm in interface Database
Returns:
the vendor term for "schema"

setSchemaTerm

public void setSchemaTerm(String schemaTerm)
Sets the database vendor's preferred term for "schema".

Specified by:
setSchemaTerm in interface Database
Parameters:
schemaTerm - the vendor term for "schema"

getProcedureTerm

public String getProcedureTerm()
Retrieves the database vendor's preferred term for "procedure".

Specified by:
getProcedureTerm in interface Database
Returns:
the vendor term for "procedure"

setProcedureTerm

public void setProcedureTerm(String procedureTerm)
Sets the database vendor's preferred term for "procedure".

Specified by:
setProcedureTerm in interface Database
Parameters:
procedureTerm - the vendor term for "procedure"

getCatalogTerm

public String getCatalogTerm()
Retrieves the database vendor's preferred term for "catalog".

Specified by:
getCatalogTerm in interface Database
Returns:
the vendor term for "catalog"

setCatalogTerm

public void setCatalogTerm(String catalogTerm)
Sets the database vendor's preferred term for "catalog".

Specified by:
setCatalogTerm in interface Database
Parameters:
catalogTerm - the vendor term for "catalog"

isCatalogAtStart

public Boolean isCatalogAtStart()
Retrieves whether a catalog appears at the start of a fully qualified table name. If not, the catalog appears at the end.

Specified by:
isCatalogAtStart in interface Database
Returns:
true if the catalog name appears at the beginning of a fully qualified table name; false otherwise

setCatalogAtStart

public void setCatalogAtStart(Boolean catalogAtStart)
Sets whether a catalog appears at the start of a fully qualified table name. If not, the catalog appears at the end.

Specified by:
setCatalogAtStart in interface Database
Parameters:
catalogAtStart - true if the catalog name appears at the beginning of a fully qualified table name; false otherwise

getCatalogSeparator

public String getCatalogSeparator()
Retrieves the String that this database uses as the separator between a catalog and table name.

Specified by:
getCatalogSeparator in interface Database
Returns:
the separator string

setCatalogSeparator

public void setCatalogSeparator(String catalogSeparator)
Sets the String that this database uses as the separator between a catalog and table name.

Specified by:
setCatalogSeparator in interface Database
Parameters:
catalogSeparator - the separator string

isSupportsSchemasInDataManipulation

public Boolean isSupportsSchemasInDataManipulation()
Retrieves whether a schema name can be used in a data manipulation statement.

Specified by:
isSupportsSchemasInDataManipulation in interface Database
Returns:
true if so; false otherwise

setSupportsSchemasInDataManipulation

public void setSupportsSchemasInDataManipulation(Boolean supportsSchemasInDataManipulation)
Sets whether a schema name can be used in a data manipulation statement.

Specified by:
setSupportsSchemasInDataManipulation in interface Database
Parameters:
supportsSchemasInDataManipulation - true if so; false otherwise

isSupportsSchemasInProcedureCalls

public Boolean isSupportsSchemasInProcedureCalls()
Retrieves whether a schema name can be used in a procedure call statement.

Specified by:
isSupportsSchemasInProcedureCalls in interface Database
Returns:
true if so; false otherwise

setSupportsSchemasInProcedureCalls

public void setSupportsSchemasInProcedureCalls(Boolean supportsSchemasInProcedureCalls)
Sets whether a schema name can be used in a procedure call statement.

Specified by:
setSupportsSchemasInProcedureCalls in interface Database
Parameters:
supportsSchemasInProcedureCalls - true if so; false otherwise

isSupportsSchemasInTableDefinitions

public Boolean isSupportsSchemasInTableDefinitions()
Retrieves whether a schema name can be used in a table definition statement.

Specified by:
isSupportsSchemasInTableDefinitions in interface Database
Returns:
true if so; false otherwise

setSupportsSchemasInTableDefinitions

public void setSupportsSchemasInTableDefinitions(Boolean supportsSchemasInTableDefinitions)
Sets whether a schema name can be used in a table definition statement.

Specified by:
setSupportsSchemasInTableDefinitions in interface Database
Parameters:
supportsSchemasInTableDefinitions - true if so; false otherwise

isSupportsSchemasInIndexDefinitions

public Boolean isSupportsSchemasInIndexDefinitions()
Retrieves whether a schema name can be used in an index definition statement.

Specified by:
isSupportsSchemasInIndexDefinitions in interface Database
Returns:
true if so; false otherwise

setSupportsSchemasInIndexDefinitions

public void setSupportsSchemasInIndexDefinitions(Boolean supportsSchemasInIndexDefinitions)
Sets whether a schema name can be used in an index definition statement.

Specified by:
setSupportsSchemasInIndexDefinitions in interface Database
Parameters:
supportsSchemasInIndexDefinitions - true if so; false otherwise

isSupportsSchemasInPrivilegeDefinitions

public Boolean isSupportsSchemasInPrivilegeDefinitions()
Retrieves whether a schema name can be used in a privilege definition statement.

Specified by:
isSupportsSchemasInPrivilegeDefinitions in interface Database
Returns:
true if so; false otherwise

setSupportsSchemasInPrivilegeDefinitions

public void setSupportsSchemasInPrivilegeDefinitions(Boolean supportsSchemasInPrivilegeDefinitions)
Sets whether a schema name can be used in a privilege definition statement.

Specified by:
setSupportsSchemasInPrivilegeDefinitions in interface Database
Parameters:
supportsSchemasInPrivilegeDefinitions - true if so; false otherwise

isSupportsCatalogsInDataManipulation

public Boolean isSupportsCatalogsInDataManipulation()
Retrieves whether a catalog name can be used in a data manipulation statement.

Specified by:
isSupportsCatalogsInDataManipulation in interface Database
Returns:
true if so; false otherwise

setSupportsCatalogsInDataManipulation

public void setSupportsCatalogsInDataManipulation(Boolean supportsCatalogsInDataManipulation)
Sets whether a catalog name can be used in a data manipulation statement.

Specified by:
setSupportsCatalogsInDataManipulation in interface Database
Parameters:
supportsCatalogsInDataManipulation - true if so; false otherwise

isSupportsCatalogsInProcedureCalls

public Boolean isSupportsCatalogsInProcedureCalls()
Retrieves whether a catalog name can be used in a procedure call statement.

Specified by:
isSupportsCatalogsInProcedureCalls in interface Database
Returns:
true if so; false otherwise

setSupportsCatalogsInProcedureCalls

public void setSupportsCatalogsInProcedureCalls(Boolean supportsCatalogsInProcedureCalls)
Sets whether a catalog name can be used in a procedure call statement.

Specified by:
setSupportsCatalogsInProcedureCalls in interface Database
Parameters:
supportsCatalogsInProcedureCalls - true if so; false otherwise

isSupportsCatalogsInTableDefinitions

public Boolean isSupportsCatalogsInTableDefinitions()
Retrieves whether a catalog name can be used in a table definition statement.

Specified by:
isSupportsCatalogsInTableDefinitions in interface Database
Returns:
true if so; false otherwise

setSupportsCatalogsInTableDefinitions

public void setSupportsCatalogsInTableDefinitions(Boolean supportsCatalogsInTableDefinitions)
Sets whether a catalog name can be used in a table definition statement.

Specified by:
setSupportsCatalogsInTableDefinitions in interface Database
Parameters:
supportsCatalogsInTableDefinitions - true if so; false otherwise

isSupportsCatalogsInIndexDefinitions

public Boolean isSupportsCatalogsInIndexDefinitions()
Retrieves whether a catalog name can be used in an index definition statement.

Specified by:
isSupportsCatalogsInIndexDefinitions in interface Database
Returns:
true if so; false otherwise

setSupportsCatalogsInIndexDefinitions

public void setSupportsCatalogsInIndexDefinitions(Boolean supportsCatalogsInIndexDefinitions)
Sets whether a catalog name can be used in an index definition statement.

Specified by:
setSupportsCatalogsInIndexDefinitions in interface Database
Parameters:
supportsCatalogsInIndexDefinitions - true if so; false otherwise

isSupportsCatalogsInPrivilegeDefinitions

public Boolean isSupportsCatalogsInPrivilegeDefinitions()
Retrieves whether a catalog name can be used in a privilege definition statement.

Specified by:
isSupportsCatalogsInPrivilegeDefinitions in interface Database
Returns:
true if so; false otherwise

setSupportsCatalogsInPrivilegeDefinitions

public void setSupportsCatalogsInPrivilegeDefinitions(Boolean supportsCatalogsInPrivilegeDefinitions)
Sets whether a catalog name can be used in a privilege definition statement.

Specified by:
setSupportsCatalogsInPrivilegeDefinitions in interface Database
Parameters:
supportsCatalogsInPrivilegeDefinitions - true if so; false otherwise

isSupportsPositionedDelete

public Boolean isSupportsPositionedDelete()
Retrieves whether this database supports positioned DELETE statements.

Specified by:
isSupportsPositionedDelete in interface Database
Returns:
true if so; false otherwise

setSupportsPositionedDelete

public void setSupportsPositionedDelete(Boolean supportsPositionedDelete)
Sets whether this database supports positioned DELETE statements.

Specified by:
setSupportsPositionedDelete in interface Database
Parameters:
supportsPositionedDelete - true if so; false otherwise

isSupportsPositionedUpdate

public Boolean isSupportsPositionedUpdate()
Retrieves whether this database supports positioned UPDATE statements.

Specified by:
isSupportsPositionedUpdate in interface Database
Returns:
true if so; false otherwise

setSupportsPositionedUpdate

public void setSupportsPositionedUpdate(Boolean supportsPositionedUpdate)
Sets whether this database supports positioned UPDATE statements.

Specified by:
setSupportsPositionedUpdate in interface Database
Parameters:
supportsPositionedUpdate - true if so; false otherwise

isSupportsSelectForUpdate

public Boolean isSupportsSelectForUpdate()
Retrieves whether this database supports SELECT FOR UPDATE statements.

Specified by:
isSupportsSelectForUpdate in interface Database
Returns:
true if so; false otherwise

setSupportsSelectForUpdate

public void setSupportsSelectForUpdate(Boolean supportsSelectForUpdate)
Sets whether this database supports SELECT FOR UPDATE statements.

Specified by:
setSupportsSelectForUpdate in interface Database
Parameters:
supportsSelectForUpdate - true if so; false otherwise

isSupportsStoredProcedures

public Boolean isSupportsStoredProcedures()
Retrieves whether this database supports stored procedure calls that use the stored procedure escape syntax.

Specified by:
isSupportsStoredProcedures in interface Database
Returns:
true if so; false otherwise

setSupportsStoredProcedures

public void setSupportsStoredProcedures(Boolean supportsStoredProcedures)
Sets whether this database supports stored procedure calls that use the stored procedure escape syntax.

Specified by:
setSupportsStoredProcedures in interface Database
Parameters:
supportsStoredProcedures - true if so; false otherwise

isSupportsSubqueriesInComparisons

public Boolean isSupportsSubqueriesInComparisons()
Retrieves whether this database supports subqueries in comparison expressions.

Specified by:
isSupportsSubqueriesInComparisons in interface Database
Returns:
true if so; false otherwise

setSupportsSubqueriesInComparisons

public void setSupportsSubqueriesInComparisons(Boolean supportsSubqueriesInComparisons)
Retrieves whether this database supports subqueries in comparison expressions.

Specified by:
setSupportsSubqueriesInComparisons in interface Database
Parameters:
supportsSubqueriesInComparisons - true if so; false otherwise

isSupportsSubqueriesInExists

public Boolean isSupportsSubqueriesInExists()
Retrieves whether this database supports subqueries in EXISTS expressions.

Specified by:
isSupportsSubqueriesInExists in interface Database
Returns:
true if so; false otherwise

setSupportsSubqueriesInExists

public void setSupportsSubqueriesInExists(Boolean supportsSubqueriesInExists)
Sets whether this database supports subqueries in EXISTS expressions.

Specified by:
setSupportsSubqueriesInExists in interface Database
Parameters:
supportsSubqueriesInExists - true if so; false otherwise

isSupportsSubqueriesInIns

public Boolean isSupportsSubqueriesInIns()
Retrieves whether this database supports subqueries in IN statements.

Specified by:
isSupportsSubqueriesInIns in interface Database
Returns:
true if so; false otherwise

setSupportsSubqueriesInIns

public void setSupportsSubqueriesInIns(Boolean supportsSubqueriesInIns)
Sets whether this database supports subqueries in IN statements.

Specified by:
setSupportsSubqueriesInIns in interface Database
Parameters:
supportsSubqueriesInIns - true if so; false otherwise

isSupportsSubqueriesInQuantifieds

public Boolean isSupportsSubqueriesInQuantifieds()
Retrieves whether this database supports subqueries in quantified expressions.

Specified by:
isSupportsSubqueriesInQuantifieds in interface Database
Returns:
true if so; false otherwise

setSupportsSubqueriesInQuantifieds

public void setSupportsSubqueriesInQuantifieds(Boolean supportsSubqueriesInQuantifieds)
Sets whether this database supports subqueries in quantified expressions.

Specified by:
setSupportsSubqueriesInQuantifieds in interface Database
Parameters:
supportsSubqueriesInQuantifieds - true if so; false otherwise

isSupportsCorrelatedSubqueries

public Boolean isSupportsCorrelatedSubqueries()
Retrieves whether this database supports correlated subqueries.

Specified by:
isSupportsCorrelatedSubqueries in interface Database
Returns:
true if so; false otherwise

setSupportsCorrelatedSubqueries

public void setSupportsCorrelatedSubqueries(Boolean supportsCorrelatedSubqueries)
Sets whether this database supports correlated subqueries.

Specified by:
setSupportsCorrelatedSubqueries in interface Database
Parameters:
supportsCorrelatedSubqueries - true if so; false otherwise

isSupportsUnion

public Boolean isSupportsUnion()
Retrieves whether this database supports SQL UNION.

Specified by:
isSupportsUnion in interface Database
Returns:
true if so; false otherwise

setSupportsUnion

public void setSupportsUnion(Boolean supportsUnion)
Sets whether this database supports SQL UNION.

Specified by:
setSupportsUnion in interface Database
Parameters:
supportsUnion - true if so; false otherwise

isSupportsUnionAll

public Boolean isSupportsUnionAll()
Retrieves whether this database supports SQL UNION ALL.

Specified by:
isSupportsUnionAll in interface Database
Returns:
true if so; false otherwise

setSupportsUnionAll

public void setSupportsUnionAll(Boolean supportsUnionAll)
Sets whether this database supports SQL UNION ALL.

Specified by:
setSupportsUnionAll in interface Database
Parameters:
supportsUnionAll - true if so; false otherwise

isSupportsOpenCursorsAcrossCommit

public Boolean isSupportsOpenCursorsAcrossCommit()
Retrieves whether this database supports keeping cursors open across commits.

Specified by:
isSupportsOpenCursorsAcrossCommit in interface Database
Returns:
true if cursors always remain open; false if they might not remain open

setSupportsOpenCursorsAcrossCommit

public void setSupportsOpenCursorsAcrossCommit(Boolean supportsOpenCursorsAcrossCommit)
Sets whether this database supports keeping cursors open across commits.

Specified by:
setSupportsOpenCursorsAcrossCommit in interface Database
Parameters:
supportsOpenCursorsAcrossCommit - true if cursors always remain open; false if they might not remain open

isSupportsOpenCursorsAcrossRollback

public Boolean isSupportsOpenCursorsAcrossRollback()
Retrieves whether this database supports keeping cursors open across rollbacks.

Specified by:
isSupportsOpenCursorsAcrossRollback in interface Database
Returns:
true if cursors always remain open; false if they might not remain open

setSupportsOpenCursorsAcrossRollback

public void setSupportsOpenCursorsAcrossRollback(Boolean supportsOpenCursorsAcrossRollback)
Sets whether this database supports keeping cursors open across rollbacks.

Specified by:
setSupportsOpenCursorsAcrossRollback in interface Database
Parameters:
supportsOpenCursorsAcrossRollback - true if cursors always remain open; false if they might not remain open

isSupportsOpenStatementsAcrossCommit

public Boolean isSupportsOpenStatementsAcrossCommit()
Retrieves whether this database supports keeping statements open across commits.

Specified by:
isSupportsOpenStatementsAcrossCommit in interface Database
Returns:
true if statements always remain open; false if they might not remain open

setSupportsOpenStatementsAcrossCommit

public void setSupportsOpenStatementsAcrossCommit(Boolean supportsOpenStatementsAcrossCommit)
sets whether this database supports keeping statements open across commits.

Specified by:
setSupportsOpenStatementsAcrossCommit in interface Database
Parameters:
supportsOpenStatementsAcrossCommit - true if statements always remain open; false if they might not remain open

isSupportsOpenStatementsAcrossRollback

public Boolean isSupportsOpenStatementsAcrossRollback()
Retrieves whether this database supports keeping statements open across rollbacks.

Specified by:
isSupportsOpenStatementsAcrossRollback in interface Database
Returns:
true if statements always remain open; false if they might not remain open

setSupportsOpenStatementsAcrossRollback

public void setSupportsOpenStatementsAcrossRollback(Boolean supportsOpenStatementsAcrossRollback)
Sets whether this database supports keeping statements open across rollbacks.

Specified by:
setSupportsOpenStatementsAcrossRollback in interface Database
Parameters:
supportsOpenStatementsAcrossRollback - true if statements always remain open; false if they might not remain open

getMaxBinaryLiteralLength

public Integer getMaxBinaryLiteralLength()
Retrieves the maximum number of hex characters this database allows in an inline binary literal.

Specified by:
getMaxBinaryLiteralLength in interface Database
Returns:
max the maximum length (in hex characters) for a binary literal; a result of zero means that there is no limit or the limit is not known

setMaxBinaryLiteralLength

public void setMaxBinaryLiteralLength(Integer maxBinaryLiteralLength)
sets the maximum number of hex characters this database allows in an inline binary literal.

Specified by:
setMaxBinaryLiteralLength in interface Database
Parameters:
maxBinaryLiteralLength - max the maximum length (in hex characters) for a binary literal; a result of zero means that there is no limit or the limit is not known

getMaxCharLiteralLength

public Integer getMaxCharLiteralLength()
Retrieves the maximum number of characters this database allows for a character literal.

Specified by:
getMaxCharLiteralLength in interface Database
Returns:
the maximum number of characters allowed for a character literal; a result of zero means that there is no limit or the limit is not known

setMaxCharLiteralLength

public void setMaxCharLiteralLength(Integer maxCharLiteralLength)
Sets the maximum number of characters this database allows for a character literal.

Specified by:
setMaxCharLiteralLength in interface Database
Parameters:
maxCharLiteralLength - the maximum number of characters allowed for a character literal; a result of zero means that there is no limit or the limit is not known

getMaxColumnNameLength

public Integer getMaxColumnNameLength()
Retrieves the maximum number of characters this database allows for a column name.

Specified by:
getMaxColumnNameLength in interface Database
Returns:
the maximum number of characters allowed for a column name; a result of zero means that there is no limit or the limit is not known

setMaxColumnNameLength

public void setMaxColumnNameLength(Integer maxColumnNameLength)
Sets the maximum number of characters this database allows for a column name.

Specified by:
setMaxColumnNameLength in interface Database
Parameters:
maxColumnNameLength - the maximum number of characters allowed for a column name; a result of zero means that there is no limit or the limit is not known

getMaxColumnsInGroupBy

public Integer getMaxColumnsInGroupBy()
Retrieves the maximum number of columns this database allows in a GROUP BY clause.

Specified by:
getMaxColumnsInGroupBy in interface Database
Returns:
the maximum number of columns allowed; a result of zero means that there is no limit or the limit is not known

setMaxColumnsInGroupBy

public void setMaxColumnsInGroupBy(Integer maxColumnsInGroupBy)
Sets the maximum number of columns this database allows in a GROUP BY clause.

Specified by:
setMaxColumnsInGroupBy in interface Database
Parameters:
maxColumnsInGroupBy - the maximum number of columns allowed; a result of zero means that there is no limit or the limit is not known

getMaxColumnsInIndex

public Integer getMaxColumnsInIndex()
Retrieves the maximum number of columns this database allows in an index.

Specified by:
getMaxColumnsInIndex in interface Database
Returns:
the maximum number of columns allowed; a result of zero means that there is no limit or the limit is not known

setMaxColumnsInIndex

public void setMaxColumnsInIndex(Integer maxColumnsInIndex)
Sets the maximum number of columns this database allows in an index.

Specified by:
setMaxColumnsInIndex in interface Database
Parameters:
maxColumnsInIndex - the maximum number of columns allowed; a result of zero means that there is no limit or the limit is not known

getMaxColumnsInOrderBy

public Integer getMaxColumnsInOrderBy()
Retrieves the maximum number of columns this database allows in an ORDER BY clause.

Specified by:
getMaxColumnsInOrderBy in interface Database
Returns:
the maximum number of columns allowed; a result of zero means that there is no limit or the limit is not known

setMaxColumnsInOrderBy

public void setMaxColumnsInOrderBy(Integer maxColumnsInOrderBy)
Sets the maximum number of columns this database allows in an ORDER BY clause.

Specified by:
setMaxColumnsInOrderBy in interface Database
Parameters:
maxColumnsInOrderBy - the maximum number of columns allowed; a result of zero means that there is no limit or the limit is not known

getMaxColumnsInSelect

public Integer getMaxColumnsInSelect()
Retrieves the maximum number of columns this database allows in a SELECT list.

Specified by:
getMaxColumnsInSelect in interface Database
Returns:
the maximum number of columns allowed; a result of zero means that there is no limit or the limit is not known

setMaxColumnsInSelect

public void setMaxColumnsInSelect(Integer maxColumnsInSelect)
Sets the maximum number of columns this database allows in a SELECT list.

Specified by:
setMaxColumnsInSelect in interface Database
Parameters:
maxColumnsInSelect - the maximum number of columns allowed; a result of zero means that there is no limit or the limit is not known

getMaxColumnsInTable

public Integer getMaxColumnsInTable()
Retrieves the maximum number of columns this database allows in a table.

Specified by:
getMaxColumnsInTable in interface Database
Returns:
the maximum number of columns allowed; a result of zero means that there is no limit or the limit is not known

setMaxColumnsInTable

public void setMaxColumnsInTable(Integer maxColumnsInTable)
Sets the maximum number of columns this database allows in a table.

Specified by:
setMaxColumnsInTable in interface Database
Parameters:
maxColumnsInTable - the maximum number of columns allowed; a result of zero means that there is no limit or the limit is not known

getMaxConnections

public Integer getMaxConnections()
Retrieves the maximum number of concurrent connections to this database that are possible.

Specified by:
getMaxConnections in interface Database
Returns:
the maximum number of active connections possible at one time; a result of zero means that there is no limit or the limit is not known

setMaxConnections

public void setMaxConnections(Integer maxConnections)
Sets the maximum number of concurrent connections to this database that are possible.

Specified by:
setMaxConnections in interface Database
Parameters:
maxConnections - the maximum number of active connections possible at one time; a result of zero means that there is no limit or the limit is not known

getMaxCursorNameLength

public Integer getMaxCursorNameLength()
Retrieves the maximum number of characters that this database allows in a cursor name.

Specified by:
getMaxCursorNameLength in interface Database
Returns:
the maximum number of characters allowed in a cursor name; a result of zero means that there is no limit or the limit is not known

setMaxCursorNameLength

public void setMaxCursorNameLength(Integer maxCursorNameLength)
Sets the maximum number of characters that this database allows in a cursor name.

Specified by:
setMaxCursorNameLength in interface Database
Parameters:
maxCursorNameLength - the maximum number of characters allowed in a cursor name; a result of zero means that there is no limit or the limit is not known

getMaxIndexLength

public Integer getMaxIndexLength()
Retrieves the maximum number of bytes this database allows for an index, including all of the parts of the index.

Specified by:
getMaxIndexLength in interface Database
Returns:
the maximum number of bytes allowed; this limit includes the composite of all the constituent parts of the index; a result of zero means that there is no limit or the limit is not known

setMaxIndexLength

public void setMaxIndexLength(Integer maxIndexLength)
Sets the maximum number of bytes this database allows for an index, including all of the parts of the index.

Specified by:
setMaxIndexLength in interface Database
Parameters:
maxIndexLength - the maximum number of bytes allowed; this limit includes the composite of all the constituent parts of the index; a result of zero means that there is no limit or the limit is not known

getMaxSchemaNameLength

public Integer getMaxSchemaNameLength()
Retrieves the maximum number of characters that this database allows in a schema name.

Specified by:
getMaxSchemaNameLength in interface Database
Returns:
the maximum number of characters allowed in a schema name; a result of zero means that there is no limit or the limit is not known

setMaxSchemaNameLength

public void setMaxSchemaNameLength(Integer maxSchemaNameLength)
Sets the maximum number of characters that this database allows in a schema name.

Specified by:
setMaxSchemaNameLength in interface Database
Parameters:
maxSchemaNameLength - the maximum number of characters allowed in a schema name; a result of zero means that there is no limit or the limit is not known

getMaxProcedureNameLength

public Integer getMaxProcedureNameLength()
Retrieves the maximum number of characters that this database allows in a procedure name.

Specified by:
getMaxProcedureNameLength in interface Database
Returns:
the maximum number of characters allowed in a procedure name; a result of zero means that there is no limit or the limit is not known

setMaxProcedureNameLength

public void setMaxProcedureNameLength(Integer maxProcedureNameLength)
Sets the maximum number of characters that this database allows in a procedure name.

Specified by:
setMaxProcedureNameLength in interface Database
Parameters:
maxProcedureNameLength - the maximum number of characters allowed in a procedure name; a result of zero means that there is no limit or the limit is not known

getMaxCatalogNameLength

public Integer getMaxCatalogNameLength()
Retrieves the maximum number of characters that this database allows in a catalog name.

Specified by:
getMaxCatalogNameLength in interface Database
Returns:
the maximum number of characters allowed in a catalog name; a result of zero means that there is no limit or the limit is not known

setMaxCatalogNameLength

public void setMaxCatalogNameLength(Integer maxCatalogNameLength)
Sets the maximum number of characters that this database allows in a catalog name.

Specified by:
setMaxCatalogNameLength in interface Database
Parameters:
maxCatalogNameLength - the maximum number of characters allowed in a catalog name; a result of zero means that there is no limit or the limit is not known

getMaxRowSize

public Integer getMaxRowSize()
Retrieves the maximum number of bytes this database allows in a single row.

Specified by:
getMaxRowSize in interface Database
Returns:
the maximum number of bytes allowed for a row; a result of zero means that there is no limit or the limit is not known

setMaxRowSize

public void setMaxRowSize(Integer maxRowSize)
Sets the maximum number of bytes this database allows in a single row.

Specified by:
setMaxRowSize in interface Database
Parameters:
maxRowSize - the maximum number of bytes allowed for a row; a result of zero means that there is no limit or the limit is not known

isMaxRowSizeIncludeBlobs

public Boolean isMaxRowSizeIncludeBlobs()
Retrieves whether the return value for the method getMaxRowSize includes the SQL data types LONGVARCHAR and LONGVARBINARY.

Specified by:
isMaxRowSizeIncludeBlobs in interface Database
Returns:
true if so; false otherwise

setMaxRowSizeIncludeBlobs

public void setMaxRowSizeIncludeBlobs(Boolean maxRowSizeIncludeBlobs)
Sets whether the return value for the method getMaxRowSize includes the SQL data types LONGVARCHAR and LONGVARBINARY.

Specified by:
setMaxRowSizeIncludeBlobs in interface Database
Parameters:
maxRowSizeIncludeBlobs - true if so; false otherwise

getMaxStatementLength

public Integer getMaxStatementLength()
Retrieves the maximum number of characters this database allows in an SQL statement.

Specified by:
getMaxStatementLength in interface Database
Returns:
the maximum number of characters allowed for an SQL statement; a result of zero means that there is no limit or the limit is not known

setMaxStatementLength

public void setMaxStatementLength(Integer maxStatementLength)
Sets the maximum number of characters this database allows in an SQL statement.

Specified by:
setMaxStatementLength in interface Database
Parameters:
maxStatementLength - the maximum number of characters allowed for an SQL statement; a result of zero means that there is no limit or the limit is not known

getMaxStatements

public Integer getMaxStatements()
Retrieves the maximum number of active statements to this database that can be open at the same time.

Specified by:
getMaxStatements in interface Database
Returns:
the maximum number of statements that can be open at one time; a result of zero means that there is no limit or the limit is not known

setMaxStatements

public void setMaxStatements(Integer maxStatements)
Sets the maximum number of active statements to this database that can be open at the same time.

Specified by:
setMaxStatements in interface Database
Parameters:
maxStatements - the maximum number of statements that can be open at one time; a result of zero means that there is no limit or the limit is not known

getMaxTableNameLength

public Integer getMaxTableNameLength()
Retrieves the maximum number of characters this database allows in a table name.

Specified by:
getMaxTableNameLength in interface Database
Returns:
the maximum number of characters allowed for a table name; a result of zero means that there is no limit or the limit is not known

setMaxTableNameLength

public void setMaxTableNameLength(Integer maxTableNameLength)
Sets the maximum number of characters this database allows in a table name.

Specified by:
setMaxTableNameLength in interface Database
Parameters:
maxTableNameLength - the maximum number of characters allowed for a table name; a result of zero means that there is no limit or the limit is not known

getMaxTablesInSelect

public Integer getMaxTablesInSelect()
Retrieves the maximum number of tables this database allows in a SELECT statement.

Specified by:
getMaxTablesInSelect in interface Database
Returns:
the maximum number of tables allowed in a SELECT statement; a result of zero means that there is no limit or the limit is not known

setMaxTablesInSelect

public void setMaxTablesInSelect(Integer maxTablesInSelect)
Sets the maximum number of tables this database allows in a SELECT statement.

Specified by:
setMaxTablesInSelect in interface Database
Parameters:
maxTablesInSelect - the maximum number of tables allowed in a SELECT statement; a result of zero means that there is no limit or the limit is not known

getMaxUserNameLength

public Integer getMaxUserNameLength()
Retrieves the maximum number of characters this database allows in a user name.

Specified by:
getMaxUserNameLength in interface Database
Returns:
the maximum number of characters allowed for a user name; a result of zero means that there is no limit or the limit is not known

setMaxUserNameLength

public void setMaxUserNameLength(Integer maxUserNameLength)
Sets the maximum number of characters this database allows in a user name.

Specified by:
setMaxUserNameLength in interface Database
Parameters:
maxUserNameLength - the maximum number of characters allowed for a user name; a result of zero means that there is no limit or the limit is not known

getDefaultTransactionIsolation

public Integer getDefaultTransactionIsolation()
Retrieves this database's default transaction isolation level. The possible values are defined in java.sql.Connection.

Specified by:
getDefaultTransactionIsolation in interface Database
Returns:
the default isolation level
See Also:
Connection

setDefaultTransactionIsolation

public void setDefaultTransactionIsolation(Integer defaultTransactionIsolation)
Sets this database's default transaction isolation level. The possible values are defined in java.sql.Connection.

Specified by:
setDefaultTransactionIsolation in interface Database
Parameters:
defaultTransactionIsolation - the default isolation level
See Also:
Connection

isSupportsTransactions

public Boolean isSupportsTransactions()
Retrieves whether this database supports transactions. If not, invoking the method commit is a noop, and the isolation level is TRANSACTION_NONE.

Specified by:
isSupportsTransactions in interface Database
Returns:
true if transactions are supported; false otherwise

setSupportsTransactions

public void setSupportsTransactions(Boolean supportsTransactions)
Sets whether this database supports transactions. If not, invoking the method commit is a noop, and the isolation level is TRANSACTION_NONE.

Specified by:
setSupportsTransactions in interface Database
Parameters:
supportsTransactions - true if transactions are supported; false otherwise

getSupportedTransactionIsolationLevels

public Set<TransactionIsolationLevelType> getSupportedTransactionIsolationLevels()
Retrieves list of database supported transaction isolation levels.

Specified by:
getSupportedTransactionIsolationLevels in interface Database
Returns:
list of database supported transaction isolation levels.
See Also:
Connection

addSupportedTransactionIsolationLevelType

public void addSupportedTransactionIsolationLevelType(TransactionIsolationLevelType transactionIsolationLevelType)
Adds TransactionIsolationLevelType

Specified by:
addSupportedTransactionIsolationLevelType in interface Database
Parameters:
transactionIsolationLevelType - the Transaction Isolation Level Type

deleteSupportedTransactionIsolationLevelType

public void deleteSupportedTransactionIsolationLevelType(TransactionIsolationLevelType transactionIsolationLevelType)
Deletes TransactionIsolationLevelType

Specified by:
deleteSupportedTransactionIsolationLevelType in interface Database
Parameters:
transactionIsolationLevelType - the Transaction Isolation Level Type

isSupportedTransactionIsolationLevelType

public Boolean isSupportedTransactionIsolationLevelType(TransactionIsolationLevelType transactionIsolationLevelType)
Is supported TransactionIsolationLevelType

Specified by:
isSupportedTransactionIsolationLevelType in interface Database
Parameters:
transactionIsolationLevelType - the Transaction Isolation Level Type
Returns:
true if supported

isSupportsDataDefinitionAndDataManipulationTransactions

public Boolean isSupportsDataDefinitionAndDataManipulationTransactions()
Retrieves whether this database supports both data definition and data manipulation statements within a transaction.

Specified by:
isSupportsDataDefinitionAndDataManipulationTransactions in interface Database
Returns:
true if so; false otherwise

setSupportsDataDefinitionAndDataManipulationTransactions

public void setSupportsDataDefinitionAndDataManipulationTransactions(Boolean supportsDataDefinitionAndDataManipulationTransactions)
Sets whether this database supports both data definition and data manipulation statements within a transaction.

Specified by:
setSupportsDataDefinitionAndDataManipulationTransactions in interface Database
Parameters:
supportsDataDefinitionAndDataManipulationTransactions - true if so; false otherwise

isSupportsDataManipulationTransactionsOnly

public Boolean isSupportsDataManipulationTransactionsOnly()
Retrieves whether this database supports only data manipulation statements within a transaction.

Specified by:
isSupportsDataManipulationTransactionsOnly in interface Database
Returns:
true if so; false otherwise

setSupportsDataManipulationTransactionsOnly

public void setSupportsDataManipulationTransactionsOnly(Boolean supportsDataManipulationTransactionsOnly)
Sets whether this database supports only data manipulation statements within a transaction.

Specified by:
setSupportsDataManipulationTransactionsOnly in interface Database
Parameters:
supportsDataManipulationTransactionsOnly - true if so; false otherwise

isDataDefinitionCausesTransactionCommit

public Boolean isDataDefinitionCausesTransactionCommit()
Retrieves whether a data definition statement within a transaction forces the transaction to commit.

Specified by:
isDataDefinitionCausesTransactionCommit in interface Database
Returns:
true if so; false otherwise

setDataDefinitionCausesTransactionCommit

public void setDataDefinitionCausesTransactionCommit(Boolean dataDefinitionCausesTransactionCommit)
Sets whether a data definition statement within a transaction forces the transaction to commit.

Specified by:
setDataDefinitionCausesTransactionCommit in interface Database
Parameters:
dataDefinitionCausesTransactionCommit - true if so; false otherwise

isDataDefinitionIgnoredInTransactions

public Boolean isDataDefinitionIgnoredInTransactions()
Retrieves whether this database ignores a data definition statement within a transaction.

Specified by:
isDataDefinitionIgnoredInTransactions in interface Database
Returns:
true if so; false otherwise

setDataDefinitionIgnoredInTransactions

public void setDataDefinitionIgnoredInTransactions(Boolean dataDefinitionIgnoredInTransactions)
Sets whether this database ignores a data definition statement within a transaction.

Specified by:
setDataDefinitionIgnoredInTransactions in interface Database
Parameters:
dataDefinitionIgnoredInTransactions - true if so; false otherwise

getStoredProcedures

public Set<StoredProcedure> getStoredProcedures()
Retrieves a description of the stored procedures available in the given catalog.

Specified by:
getStoredProcedures in interface Database
Returns:
a set of stored procedures available

addStoredProcedure

public void addStoredProcedure(StoredProcedure storedProcedure)
Adds Stored Procedure

Specified by:
addStoredProcedure in interface Database
Parameters:
storedProcedure - the Stored Procedure

deleteStoredProcedure

public void deleteStoredProcedure(StoredProcedure storedProcedure)
Deletes Stored Procedure

Specified by:
deleteStoredProcedure in interface Database
Parameters:
storedProcedure - the Stored Procedure

findStoredProcedureByName

public StoredProcedure findStoredProcedureByName(String catalog,
                                                 String schema,
                                                 String procedureName)
Finds stored procedute by its name.

Specified by:
findStoredProcedureByName in interface Database
Parameters:
catalog - a catalog name; must match the catalog name as it is stored in the database; "" retrieves those without a catalog; null means that the catalog name should not be used to narrow the search
schema - a schema name; must match the schema name as it is stored in the database; "" retrieves those without a schema; null means that the schema name should not be used to narrow the search
procedureName - a procedure name; must match the procedure name as it is stored in the database
Returns:
stored procedure or null if not found

getTables

public Set<Table> getTables()
Retrieves a description of the tables available in the given catalog.

Specified by:
getTables in interface Database
Returns:
a set of tables available

addTable

public void addTable(Table table)
Adds Table

Specified by:
addTable in interface Database
Parameters:
table - the table to add

deleteTable

public void deleteTable(Table table)
Deletes Table

Specified by:
deleteTable in interface Database
Parameters:
table - the table to delete

findTableByName

public Table findTableByName(String catalog,
                             String schema,
                             String tableName)
Finds table by its name.

Specified by:
findTableByName in interface Database
Parameters:
catalog - a catalog name; must match the catalog name as it is stored in the database; "" retrieves those without a catalog; null means that the catalog name should not be used to narrow the search
schema - a schema name; must match the schema name as it is stored in the database; "" retrieves those without a schema; null means that the schema name should not be used to narrow the search
tableName - a table name; must match the table name as it is stored in the database
Returns:
table or null if not found

getSchemas

public Set<Schema> getSchemas()
Retrieves the schemas available in this database. The results are ordered by schema name.

Specified by:
getSchemas in interface Database
Returns:
schemas available in this database.

addSchema

public void addSchema(Schema schema)
Adds Schema

Specified by:
addSchema in interface Database
Parameters:
schema - the Schema

deleteSchema

public void deleteSchema(Schema schema)
Deletes Schema

Specified by:
deleteSchema in interface Database
Parameters:
schema - the Schema

findSchemaByName

public Schema findSchemaByName(String catalog,
                               String schemaName)
Finds schema by its name.

Specified by:
findSchemaByName in interface Database
Parameters:
catalog - a catalog name; must match the catalog name as it is stored in the database; "" retrieves those without a catalog; null means that the catalog name should not be used to narrow the search
schemaName - a schema name; must match the schema name as it is stored in the database;
Returns:
schema or null if not found

getCatalogs

public Set<Catalog> getCatalogs()
Retrieves the catalogs available in this database

Specified by:
getCatalogs in interface Database
Returns:
catalogs available in this database

addCatalog

public void addCatalog(Catalog catalog)
Adds Catalog

Specified by:
addCatalog in interface Database
Parameters:
catalog - the catalog to add

deleteCatalog

public void deleteCatalog(Catalog catalog)
Deletes Catalog

Specified by:
deleteCatalog in interface Database
Parameters:
catalog - the catalog to delete

findCatalogByName

public Catalog findCatalogByName(String catalogName)
Finds catalog by its name.

Specified by:
findCatalogByName in interface Database
Parameters:
catalogName - a catalog name; must match the catalog name as it is stored in the database;
Returns:
catalog or null if not found

getTableTypes

public Set<TableType> getTableTypes()
Retrieves the table types available in this database. The results are ordered by table type.

The table type is:

  1. TABLE_TYPE String => table type. Typical types are "TABLE", "VIEW", "SYSTEM TABLE", "GLOBAL TEMPORARY", "LOCAL TEMPORARY", "ALIAS", "SYNONYM".

Specified by:
getTableTypes in interface Database
Returns:
table types available in this database

addTableType

public void addTableType(TableType tableType)
Adds TableType

Specified by:
addTableType in interface Database
Parameters:
tableType - the table type to add

deleteTableType

public void deleteTableType(TableType tableType)
Deletes TableType

Specified by:
deleteTableType in interface Database
Parameters:
tableType - the table type to delete

findTableTypeByTypeName

public TableType findTableTypeByTypeName(String typeName)
Finds table type by its name.

Specified by:
findTableTypeByTypeName in interface Database
Parameters:
typeName - a table type name; must match the type name as it is stored in the database;
Returns:
table type or null if not found

getSqlTypeInfos

public Set<SqlTypeInfo> getSqlTypeInfos()
Retrieves a description of all the standard SQL types supported by this database

Specified by:
getSqlTypeInfos in interface Database
Returns:
all the standard SQL types supported by this database

addSqlTypeInfo

public void addSqlTypeInfo(SqlTypeInfo sqlTypeInfo)
Adds SqlTypeInfo

Specified by:
addSqlTypeInfo in interface Database
Parameters:
sqlTypeInfo - the SQL type to add

deleteSqlTypeInfo

public void deleteSqlTypeInfo(SqlTypeInfo sqlTypeInfo)
Deletes SqlTypeInfo

Specified by:
deleteSqlTypeInfo in interface Database
Parameters:
sqlTypeInfo - the SQL type to delete

findSqlTypeInfoByTypeName

public SqlTypeInfo findSqlTypeInfoByTypeName(String typeName)
Finds SQL type by its name.

Specified by:
findSqlTypeInfoByTypeName in interface Database
Parameters:
typeName - a table type name; must match the type name as it is stored in the database;
Returns:
table type or null if not found

getSupportedResultSetTypes

public Set<ResultSetType> getSupportedResultSetTypes()
Retrieves database supported result set types.

Specified by:
getSupportedResultSetTypes in interface Database
Returns:
database supported result set types.
Since:
1.2 (JDBC 2.0)
See Also:
Connection

addSupportedResultSetType

public void addSupportedResultSetType(ResultSetType resultSetType)
Adds supported ResultSetType

Specified by:
addSupportedResultSetType in interface Database
Parameters:
resultSetType - the ResultSetType

deleteSupportedResultSetType

public void deleteSupportedResultSetType(ResultSetType resultSetType)
Deletes supported ResultSetType

Specified by:
deleteSupportedResultSetType in interface Database
Parameters:
resultSetType - the ResultSetType

getSupportedForwardOnlyResultSetConcurrencies

public Set<ResultSetConcurrencyType> getSupportedForwardOnlyResultSetConcurrencies()
Retrieves database supported concurrencies for the given result set type.

Specified by:
getSupportedForwardOnlyResultSetConcurrencies in interface Database
Returns:
database supported concurrencies for the given result set type.
Since:
1.2 (JDBC 2.0)
See Also:
Connection

addSupportedForwardOnlyResultSetConcurrency

public void addSupportedForwardOnlyResultSetConcurrency(ResultSetConcurrencyType resultSetConcurrencyType)
Adds ResultSetConcurrencyType

Specified by:
addSupportedForwardOnlyResultSetConcurrency in interface Database
Parameters:
resultSetConcurrencyType - the ResultSetConcurrencyType

deleteSupportedForwardOnlyResultSetConcurrency

public void deleteSupportedForwardOnlyResultSetConcurrency(ResultSetConcurrencyType resultSetConcurrencyType)
Deletes ResultSetConcurrencyType

Specified by:
deleteSupportedForwardOnlyResultSetConcurrency in interface Database
Parameters:
resultSetConcurrencyType - the ResultSetConcurrencyType

getSupportedScrollInsensitiveResultSetConcurrencies

public Set<ResultSetConcurrencyType> getSupportedScrollInsensitiveResultSetConcurrencies()
Retrieves database supported concurrencies for the given result set type.

Specified by:
getSupportedScrollInsensitiveResultSetConcurrencies in interface Database
Returns:
database supported concurrencies for the given result set type.
Since:
1.2 (JDBC 2.0)
See Also:
Connection

addSupportedScrollInsensitiveResultSetConcurrency

public void addSupportedScrollInsensitiveResultSetConcurrency(ResultSetConcurrencyType resultSetConcurrencyType)
Adds ResultSetConcurrencyType

Specified by:
addSupportedScrollInsensitiveResultSetConcurrency in interface Database
Parameters:
resultSetConcurrencyType - the ResultSetConcurrencyType

deleteSupportedScrollInsensitiveResultSetConcurrency

public void deleteSupportedScrollInsensitiveResultSetConcurrency(ResultSetConcurrencyType resultSetConcurrencyType)
Delete ResultSetConcurrencyType

Specified by:
deleteSupportedScrollInsensitiveResultSetConcurrency in interface Database
Parameters:
resultSetConcurrencyType - the ResultSetConcurrencyType

getSupportedScrollSensitiveResultSetConcurrencies

public Set<ResultSetConcurrencyType> getSupportedScrollSensitiveResultSetConcurrencies()
Retrieves database supported concurrencies for the given result set type.

Specified by:
getSupportedScrollSensitiveResultSetConcurrencies in interface Database
Returns:
database supported concurrencies for the given result set type.
Since:
1.2 (JDBC 2.0)
See Also:
Connection

addSupportedScrollSensitiveResultSetConcurrency

public void addSupportedScrollSensitiveResultSetConcurrency(ResultSetConcurrencyType resultSetConcurrencyType)
Adds resultSetConcurrencyType

Specified by:
addSupportedScrollSensitiveResultSetConcurrency in interface Database
Parameters:
resultSetConcurrencyType - the ResultSetConcurrencyType

deleteSupportedScrollSensitiveResultSetConcurrency

public void deleteSupportedScrollSensitiveResultSetConcurrency(ResultSetConcurrencyType resultSetConcurrencyType)
deletes resultSetConcurrencyType

Specified by:
deleteSupportedScrollSensitiveResultSetConcurrency in interface Database
Parameters:
resultSetConcurrencyType - the ResultSetConcurrencyType

isForwardOnlyResultSetOwnUpdatesAreVisible

public Boolean isForwardOnlyResultSetOwnUpdatesAreVisible()
Retrieves whether for the given type of ResultSet object, the result set's own updates are visible.

Specified by:
isForwardOnlyResultSetOwnUpdatesAreVisible in interface Database
Returns:
true if updates are visible for the given result set type; false otherwise
Since:
1.2 (JDBC 2.0)

setForwardOnlyResultSetOwnUpdatesAreVisible

public void setForwardOnlyResultSetOwnUpdatesAreVisible(Boolean forwardOnlyResultSetOwnUpdatesAreVisible)
Sets whether for the given type of ResultSet object, the result set's own updates are visible.

Specified by:
setForwardOnlyResultSetOwnUpdatesAreVisible in interface Database
Parameters:
forwardOnlyResultSetOwnUpdatesAreVisible - true if updates are visible for the given result set type; false otherwise
Since:
1.2 (JDBC 2.0)

isScrollInsensitiveResultSetOwnUpdatesAreVisible

public Boolean isScrollInsensitiveResultSetOwnUpdatesAreVisible()
Retrieves whether for the given type of ResultSet object, the result set's own updates are visible.

Specified by:
isScrollInsensitiveResultSetOwnUpdatesAreVisible in interface Database
Returns:
true if updates are visible for the given result set type; false otherwise
Since:
1.2 (JDBC 2.0)

setScrollInsensitiveResultSetOwnUpdatesAreVisible

public void setScrollInsensitiveResultSetOwnUpdatesAreVisible(Boolean scrollInsensitiveResultSetOwnUpdatesAreVisible)
Sets whether for the given type of ResultSet object, the result set's own updates are visible.

Specified by:
setScrollInsensitiveResultSetOwnUpdatesAreVisible in interface Database
Parameters:
scrollInsensitiveResultSetOwnUpdatesAreVisible - true if updates are visible for the given result set type; false otherwise
Since:
1.2 (JDBC 2.0)

isScrollSensitiveResultSetOwnUpdatesAreVisible

public Boolean isScrollSensitiveResultSetOwnUpdatesAreVisible()
Retrieves whether for the given type of ResultSet object, the result set's own updates are visible.

Specified by:
isScrollSensitiveResultSetOwnUpdatesAreVisible in interface Database
Returns:
true if updates are visible for the given result set type; false otherwise
Since:
1.2 (JDBC 2.0)

setScrollSensitiveResultSetOwnUpdatesAreVisible

public void setScrollSensitiveResultSetOwnUpdatesAreVisible(Boolean scrollSensitiveResultSetOwnUpdatesAreVisible)
Sets whether for the given type of ResultSet object, the result set's own updates are visible.

Specified by:
setScrollSensitiveResultSetOwnUpdatesAreVisible in interface Database
Parameters:
scrollSensitiveResultSetOwnUpdatesAreVisible - true if updates are visible for the given result set type; false otherwise
Since:
1.2 (JDBC 2.0)

isForwardOnlyResultSetOwnDeletesAreVisible

public Boolean isForwardOnlyResultSetOwnDeletesAreVisible()
Retrieves whether a result set's own deletes are visible.

Specified by:
isForwardOnlyResultSetOwnDeletesAreVisible in interface Database
Returns:
true if deletes are visible for the given result set type; false otherwise
Since:
1.2 (JDBC 2.0)

setForwardOnlyResultSetOwnDeletesAreVisible

public void setForwardOnlyResultSetOwnDeletesAreVisible(Boolean forwardOnlyResultSetOwnDeletesAreVisible)
Sets whether a result set's own deletes are visible.

Specified by:
setForwardOnlyResultSetOwnDeletesAreVisible in interface Database
Parameters:
forwardOnlyResultSetOwnDeletesAreVisible - true if deletes are visible for the given result set type; false otherwise
Since:
1.2 (JDBC 2.0)

isScrollInsensitiveResultSetOwnDeletesAreVisible

public Boolean isScrollInsensitiveResultSetOwnDeletesAreVisible()
Retrieves whether a result set's own deletes are visible.

Specified by:
isScrollInsensitiveResultSetOwnDeletesAreVisible in interface Database
Returns:
true if deletes are visible for the given result set type; false otherwise
Since:
1.2 (JDBC 2.0)

setScrollInsensitiveResultSetOwnDeletesAreVisible

public void setScrollInsensitiveResultSetOwnDeletesAreVisible(Boolean scrollInsensitiveResultSetOwnDeletesAreVisible)
Sets whether a result set's own deletes are visible.

Specified by:
setScrollInsensitiveResultSetOwnDeletesAreVisible in interface Database
Parameters:
scrollInsensitiveResultSetOwnDeletesAreVisible - true if deletes are visible for the given result set type; false otherwise
Since:
1.2 (JDBC 2.0)

isScrollSensitiveResultSetOwnDeletesAreVisible

public Boolean isScrollSensitiveResultSetOwnDeletesAreVisible()
Retrieves whether a result set's own deletes are visible.

Specified by:
isScrollSensitiveResultSetOwnDeletesAreVisible in interface Database
Returns:
true if deletes are visible for the given result set type; false otherwise
Since:
1.2 (JDBC 2.0)

setScrollSensitiveResultSetOwnDeletesAreVisible

public void setScrollSensitiveResultSetOwnDeletesAreVisible(Boolean scrollSensitiveResultSetOwnDeletesAreVisible)
Sets whether a result set's own deletes are visible.

Specified by:
setScrollSensitiveResultSetOwnDeletesAreVisible in interface Database
Parameters:
scrollSensitiveResultSetOwnDeletesAreVisible - true if deletes are visible for the given result set type; false otherwise
Since:
1.2 (JDBC 2.0)

isForwardOnlyResultSetOwnInsertsAreVisible

public Boolean isForwardOnlyResultSetOwnInsertsAreVisible()
Retrieves whether a result set's own inserts are visible.

Specified by:
isForwardOnlyResultSetOwnInsertsAreVisible in interface Database
Returns:
true if inserts are visible for the given result set type; false otherwise
Since:
1.2 (JDBC 2.0)

setForwardOnlyResultSetOwnInsertsAreVisible

public void setForwardOnlyResultSetOwnInsertsAreVisible(Boolean forwardOnlyResultSetOwnInsertsAreVisible)
Sets whether a result set's own inserts are visible.

Specified by:
setForwardOnlyResultSetOwnInsertsAreVisible in interface Database
Parameters:
forwardOnlyResultSetOwnInsertsAreVisible - true if inserts are visible for the given result set type; false otherwise
Since:
1.2 (JDBC 2.0)

isScrollInsensitiveResultSetOwnInsertsAreVisible

public Boolean isScrollInsensitiveResultSetOwnInsertsAreVisible()
Retrieves whether a result set's own inserts are visible.

Specified by:
isScrollInsensitiveResultSetOwnInsertsAreVisible in interface Database
Returns:
true if inserts are visible for the given result set type; false otherwise
Since:
1.2 (JDBC 2.0)

setScrollInsensitiveResultSetOwnInsertsAreVisible

public void setScrollInsensitiveResultSetOwnInsertsAreVisible(Boolean scrollInsensitiveResultSetOwnInsertsAreVisible)
Sets whether a result set's own inserts are visible.

Specified by:
setScrollInsensitiveResultSetOwnInsertsAreVisible in interface Database
Parameters:
scrollInsensitiveResultSetOwnInsertsAreVisible - true if inserts are visible for the given result set type; false otherwise
Since:
1.2 (JDBC 2.0)

isScrollSensitiveResultSetOwnInsertsAreVisible

public Boolean isScrollSensitiveResultSetOwnInsertsAreVisible()
Retrieves whether a result set's own inserts are visible.

Specified by:
isScrollSensitiveResultSetOwnInsertsAreVisible in interface Database
Returns:
true if inserts are visible for the given result set type; false otherwise
Since:
1.2 (JDBC 2.0)

setScrollSensitiveResultSetOwnInsertsAreVisible

public void setScrollSensitiveResultSetOwnInsertsAreVisible(Boolean scrollSensitiveResultSetOwnInsertsAreVisible)
Sets whether a result set's own inserts are visible.

Specified by:
setScrollSensitiveResultSetOwnInsertsAreVisible in interface Database
Parameters:
scrollSensitiveResultSetOwnInsertsAreVisible - true if inserts are visible for the given result set type; false otherwise
Since:
1.2 (JDBC 2.0)

isForwardOnlyResultSetOthersUpdatesAreVisible

public Boolean isForwardOnlyResultSetOthersUpdatesAreVisible()
Retrieves whether updates made by others are visible.

Specified by:
isForwardOnlyResultSetOthersUpdatesAreVisible in interface Database
Returns:
true if updates made by others are visible for the given result set type; false otherwise
Since:
1.2 (JDBC 2.0)

setForwardOnlyResultSetOthersUpdatesAreVisible

public void setForwardOnlyResultSetOthersUpdatesAreVisible(Boolean forwardOnlyResultSetOthersUpdatesAreVisible)
Sets whether updates made by others are visible.

Specified by:
setForwardOnlyResultSetOthersUpdatesAreVisible in interface Database
Parameters:
forwardOnlyResultSetOthersUpdatesAreVisible - true if updates made by others are visible for the given result set type; false otherwise
Since:
1.2 (JDBC 2.0)

isScrollInsensitiveResultSetOthersUpdatesAreVisible

public Boolean isScrollInsensitiveResultSetOthersUpdatesAreVisible()
Retrieves whether updates made by others are visible.

Specified by:
isScrollInsensitiveResultSetOthersUpdatesAreVisible in interface Database
Returns:
true if updates made by others are visible for the given result set type; false otherwise
Since:
1.2 (JDBC 2.0)

setScrollInsensitiveResultSetOthersUpdatesAreVisible

public void setScrollInsensitiveResultSetOthersUpdatesAreVisible(Boolean scrollInsensitiveResultSetOthersUpdatesAreVisible)
Sets whether updates made by others are visible.

Specified by:
setScrollInsensitiveResultSetOthersUpdatesAreVisible in interface Database
Parameters:
scrollInsensitiveResultSetOthersUpdatesAreVisible - true if updates made by others are visible for the given result set type; false otherwise
Since:
1.2 (JDBC 2.0)

isScrollSensitiveResultSetOthersUpdatesAreVisible

public Boolean isScrollSensitiveResultSetOthersUpdatesAreVisible()
Retrieves whether updates made by others are visible.

Specified by:
isScrollSensitiveResultSetOthersUpdatesAreVisible in interface Database
Returns:
true if updates made by others are visible for the given result set type; false otherwise
Since:
1.2 (JDBC 2.0)

setScrollSensitiveResultSetOthersUpdatesAreVisible

public void setScrollSensitiveResultSetOthersUpdatesAreVisible(Boolean scrollSensitiveResultSetOthersUpdatesAreVisible)
Sets whether updates made by others are visible.

Specified by:
setScrollSensitiveResultSetOthersUpdatesAreVisible in interface Database
Parameters:
scrollSensitiveResultSetOthersUpdatesAreVisible - true if updates made by others are visible for the given result set type; false otherwise
Since:
1.2 (JDBC 2.0)

isForwardOnlyResultSetOthersDeletesAreVisible

public Boolean isForwardOnlyResultSetOthersDeletesAreVisible()
Retrieves whether deletes made by others are visible.

Specified by:
isForwardOnlyResultSetOthersDeletesAreVisible in interface Database
Returns:
true if deletes made by others are visible for the given result set type; false otherwise
Since:
1.2 (JDBC 2.0)

setForwardOnlyResultSetOthersDeletesAreVisible

public void setForwardOnlyResultSetOthersDeletesAreVisible(Boolean forwardOnlyResultSetOthersDeletesAreVisible)
Sets whether deletes made by others are visible.

Specified by:
setForwardOnlyResultSetOthersDeletesAreVisible in interface Database
Parameters:
forwardOnlyResultSetOthersDeletesAreVisible - true if deletes made by others are visible for the given result set type; false otherwise
Since:
1.2 (JDBC 2.0)

isScrollInsensitiveResultSetOthersDeletesAreVisible

public Boolean isScrollInsensitiveResultSetOthersDeletesAreVisible()
Retrieves whether deletes made by others are visible.

Specified by:
isScrollInsensitiveResultSetOthersDeletesAreVisible in interface Database
Returns:
true if deletes made by others are visible for the given result set type; false otherwise
Since:
1.2 (JDBC 2.0)

setScrollInsensitiveResultSetOthersDeletesAreVisible

public void setScrollInsensitiveResultSetOthersDeletesAreVisible(Boolean scrollInsensitiveResultSetOthersDeletesAreVisible)
Sets whether deletes made by others are visible.

Specified by:
setScrollInsensitiveResultSetOthersDeletesAreVisible in interface Database
Parameters:
scrollInsensitiveResultSetOthersDeletesAreVisible - true if deletes made by others are visible for the given result set type; false otherwise
Since:
1.2 (JDBC 2.0)

isScrollSensitiveResultSetOthersDeletesAreVisible

public Boolean isScrollSensitiveResultSetOthersDeletesAreVisible()
Retrieves whether deletes made by others are visible.

Specified by:
isScrollSensitiveResultSetOthersDeletesAreVisible in interface Database
Returns:
true if deletes made by others are visible for the given result set type; false otherwise
Since:
1.2 (JDBC 2.0)

setScrollSensitiveResultSetOthersDeletesAreVisible

public void setScrollSensitiveResultSetOthersDeletesAreVisible(Boolean scrollSensitiveResultSetOthersDeletesAreVisible)
Sets whether deletes made by others are visible.

Specified by:
setScrollSensitiveResultSetOthersDeletesAreVisible in interface Database
Parameters:
scrollSensitiveResultSetOthersDeletesAreVisible - true if deletes made by others are visible for the given result set type; false otherwise
Since:
1.2 (JDBC 2.0)

isForwardOnlyResultSetOthersInsertsAreVisible

public Boolean isForwardOnlyResultSetOthersInsertsAreVisible()
Retrieves whether inserts made by others are visible.

Specified by:
isForwardOnlyResultSetOthersInsertsAreVisible in interface Database
Returns:
true if inserts made by others are visible for the given result set type; false otherwise
Since:
1.2 (JDBC 2.0)

setForwardOnlyResultSetOthersInsertsAreVisible

public void setForwardOnlyResultSetOthersInsertsAreVisible(Boolean forwardOnlyResultSetOthersInsertsAreVisible)
Sets whether inserts made by others are visible.

Specified by:
setForwardOnlyResultSetOthersInsertsAreVisible in interface Database
Parameters:
forwardOnlyResultSetOthersInsertsAreVisible - true if inserts made by others are visible for the given result set type; false otherwise
Since:
1.2 (JDBC 2.0)

isScrollInsensitiveResultSetOthersInsertsAreVisible

public Boolean isScrollInsensitiveResultSetOthersInsertsAreVisible()
Retrieves whether inserts made by others are visible.

Specified by:
isScrollInsensitiveResultSetOthersInsertsAreVisible in interface Database
Returns:
true if inserts made by others are visible for the given result set type; false otherwise
Since:
1.2 (JDBC 2.0)

setScrollInsensitiveResultSetOthersInsertsAreVisible

public void setScrollInsensitiveResultSetOthersInsertsAreVisible(Boolean scrollInsensitiveResultSetOthersInsertsAreVisible)
Sets whether inserts made by others are visible.

Specified by:
setScrollInsensitiveResultSetOthersInsertsAreVisible in interface Database
Parameters:
scrollInsensitiveResultSetOthersInsertsAreVisible - true if inserts made by others are visible for the given result set type; false otherwise
Since:
1.2 (JDBC 2.0)

isScrollSensitiveResultSetOthersInsertsAreVisible

public Boolean isScrollSensitiveResultSetOthersInsertsAreVisible()
Retrieves whether inserts made by others are visible.

Specified by:
isScrollSensitiveResultSetOthersInsertsAreVisible in interface Database
Returns:
true if inserts made by others are visible for the given result set type; false otherwise
Since:
1.2 (JDBC 2.0)

setScrollSensitiveResultSetOthersInsertsAreVisible

public void setScrollSensitiveResultSetOthersInsertsAreVisible(Boolean scrollSensitiveResultSetOthersInsertsAreVisible)
Sets whether inserts made by others are visible.

Specified by:
setScrollSensitiveResultSetOthersInsertsAreVisible in interface Database
Parameters:
scrollSensitiveResultSetOthersInsertsAreVisible - true if inserts made by others are visible for the given result set type; false otherwise
Since:
1.2 (JDBC 2.0)

isForwardOnlyResultSetUpdatesAreDetected

public Boolean isForwardOnlyResultSetUpdatesAreDetected()
Retrieves whether or not a visible row update can be detected by calling the method ResultSet.rowUpdated.

Specified by:
isForwardOnlyResultSetUpdatesAreDetected in interface Database
Returns:
true if changes are detected by the result set type; false otherwise
Since:
1.2 (JDBC 2.0)

setForwardOnlyResultSetUpdatesAreDetected

public void setForwardOnlyResultSetUpdatesAreDetected(Boolean forwardOnlyResultSetUpdatesAreDetected)
Sets whether or not a visible row update can be detected by calling the method ResultSet.rowUpdated.

Specified by:
setForwardOnlyResultSetUpdatesAreDetected in interface Database
Parameters:
forwardOnlyResultSetUpdatesAreDetected - true if changes are detected by the result set type; false otherwise
Since:
1.2 (JDBC 2.0)

isScrollInsensitiveResultSetUpdatesAreDetected

public Boolean isScrollInsensitiveResultSetUpdatesAreDetected()
Retrieves whether or not a visible row update can be detected by calling the method ResultSet.rowUpdated.

Specified by:
isScrollInsensitiveResultSetUpdatesAreDetected in interface Database
Returns:
true if changes are detected by the result set type; false otherwise
Since:
1.2 (JDBC 2.0)

setScrollInsensitiveResultSetUpdatesAreDetected

public void setScrollInsensitiveResultSetUpdatesAreDetected(Boolean scrollInsensitiveResultSetUpdatesAreDetected)
Sets whether or not a visible row update can be detected by calling the method ResultSet.rowUpdated.

Specified by:
setScrollInsensitiveResultSetUpdatesAreDetected in interface Database
Parameters:
scrollInsensitiveResultSetUpdatesAreDetected - true if changes are detected by the result set type; false otherwise
Since:
1.2 (JDBC 2.0)

isScrollSensitiveResultSetUpdatesAreDetected

public Boolean isScrollSensitiveResultSetUpdatesAreDetected()
Retrieves whether or not a visible row update can be detected by calling the method ResultSet.rowUpdated.

Specified by:
isScrollSensitiveResultSetUpdatesAreDetected in interface Database
Returns:
true if changes are detected by the result set type; false otherwise
Since:
1.2 (JDBC 2.0)

setScrollSensitiveResultSetUpdatesAreDetected

public void setScrollSensitiveResultSetUpdatesAreDetected(Boolean scrollSensitiveResultSetUpdatesAreDetected)
Sets whether or not a visible row update can be detected by calling the method ResultSet.rowUpdated.

Specified by:
setScrollSensitiveResultSetUpdatesAreDetected in interface Database
Parameters:
scrollSensitiveResultSetUpdatesAreDetected - true if changes are detected by the result set type; false otherwise
Since:
1.2 (JDBC 2.0)

isForwardOnlyResultSetDeletesAreDetected

public Boolean isForwardOnlyResultSetDeletesAreDetected()
Retrieves whether or not a visible row delete can be detected by calling the method ResultSet.rowDeleted. If the method deletesAreDetected returns false, it means that deleted rows are removed from the result set.

Specified by:
isForwardOnlyResultSetDeletesAreDetected in interface Database
Returns:
true if deletes are detected by the given result set type; false otherwise
Since:
1.2 (JDBC 2.0)

setForwardOnlyResultSetDeletesAreDetected

public void setForwardOnlyResultSetDeletesAreDetected(Boolean forwardOnlyResultSetDeletesAreDetected)
Sets whether or not a visible row delete can be detected by calling the method ResultSet.rowDeleted. If the method deletesAreDetected returns false, it means that deleted rows are removed from the result set.

Specified by:
setForwardOnlyResultSetDeletesAreDetected in interface Database
Parameters:
forwardOnlyResultSetDeletesAreDetected - true if deletes are detected by the given result set type; false otherwise
Since:
1.2 (JDBC 2.0)

isScrollInsensitiveResultSetDeletesAreDetected

public Boolean isScrollInsensitiveResultSetDeletesAreDetected()
Retrieves whether or not a visible row delete can be detected by calling the method ResultSet.rowDeleted. If the method deletesAreDetected returns false, it means that deleted rows are removed from the result set.

Specified by:
isScrollInsensitiveResultSetDeletesAreDetected in interface Database
Returns:
true if deletes are detected by the given result set type; false otherwise
Since:
1.2 (JDBC 2.0)

setScrollInsensitiveResultSetDeletesAreDetected

public void setScrollInsensitiveResultSetDeletesAreDetected(Boolean scrollInsensitiveResultSetDeletesAreDetected)
Sets whether or not a visible row delete can be detected by calling the method ResultSet.rowDeleted. If the method deletesAreDetected returns false, it means that deleted rows are removed from the result set.

Specified by:
setScrollInsensitiveResultSetDeletesAreDetected in interface Database
Parameters:
scrollInsensitiveResultSetDeletesAreDetected - true if deletes are detected by the given result set type; false otherwise
Since:
1.2 (JDBC 2.0)

isScrollSensitiveResultSetDeletesAreDetected

public Boolean isScrollSensitiveResultSetDeletesAreDetected()
Retrieves whether or not a visible row delete can be detected by calling the method ResultSet.rowDeleted. If the method deletesAreDetected returns false, it means that deleted rows are removed from the result set.

Specified by:
isScrollSensitiveResultSetDeletesAreDetected in interface Database
Returns:
true if deletes are detected by the given result set type; false otherwise
Since:
1.2 (JDBC 2.0)

setScrollSensitiveResultSetDeletesAreDetected

public void setScrollSensitiveResultSetDeletesAreDetected(Boolean scrollSensitiveResultSetDeletesAreDetected)
Sets whether or not a visible row delete can be detected by calling the method ResultSet.rowDeleted. If the method deletesAreDetected returns false, it means that deleted rows are removed from the result set.

Specified by:
setScrollSensitiveResultSetDeletesAreDetected in interface Database
Parameters:
scrollSensitiveResultSetDeletesAreDetected - true if deletes are detected by the given result set type; false otherwise
Since:
1.2 (JDBC 2.0)

isForwardOnlyResultInsertsAreDetected

public Boolean isForwardOnlyResultInsertsAreDetected()
Retrieves whether or not a visible row insert can be detected by calling the method ResultSet.rowInserted.

Specified by:
isForwardOnlyResultInsertsAreDetected in interface Database
Returns:
true if changes are detected by the specified result set type; false otherwise
Since:
1.2 (JDBC 2.0)

setForwardOnlyResultInsertsAreDetected

public void setForwardOnlyResultInsertsAreDetected(Boolean forwardOnlyResultInsertsAreDetected)
Sets whether or not a visible row insert can be detected by calling the method ResultSet.rowInserted.

Specified by:
setForwardOnlyResultInsertsAreDetected in interface Database
Parameters:
forwardOnlyResultInsertsAreDetected - true if changes are detected by the specified result set type; false otherwise
Since:
1.2 (JDBC 2.0)

isScrollInsensitiveResultInsertsAreDetected

public Boolean isScrollInsensitiveResultInsertsAreDetected()
Retrieves whether or not a visible row insert can be detected by calling the method ResultSet.rowInserted.

Specified by:
isScrollInsensitiveResultInsertsAreDetected in interface Database
Returns:
true if changes are detected by the specified result set type; false otherwise
Since:
1.2 (JDBC 2.0)

setScrollInsensitiveResultInsertsAreDetected

public void setScrollInsensitiveResultInsertsAreDetected(Boolean scrollInsensitiveResultInsertsAreDetected)
Sets whether or not a visible row insert can be detected by calling the method ResultSet.rowInserted.

Specified by:
setScrollInsensitiveResultInsertsAreDetected in interface Database
Parameters:
scrollInsensitiveResultInsertsAreDetected - true if changes are detected by the specified result set type; false otherwise
Since:
1.2 (JDBC 2.0)

isScrollSensitiveResultInsertsAreDetected

public Boolean isScrollSensitiveResultInsertsAreDetected()
Retrieves whether or not a visible row insert can be detected by calling the method ResultSet.rowInserted.

Specified by:
isScrollSensitiveResultInsertsAreDetected in interface Database
Returns:
true if changes are detected by the specified result set type; false otherwise
Since:
1.2 (JDBC 2.0)

setScrollSensitiveResultInsertsAreDetected

public void setScrollSensitiveResultInsertsAreDetected(Boolean scrollSensitiveResultInsertsAreDetected)
Sets whether or not a visible row insert can be detected by calling the method ResultSet.rowInserted.

Specified by:
setScrollSensitiveResultInsertsAreDetected in interface Database
Parameters:
scrollSensitiveResultInsertsAreDetected - true if changes are detected by the specified result set type; false otherwise
Since:
1.2 (JDBC 2.0)

isSupportsBatchUpdates

public Boolean isSupportsBatchUpdates()
Retrieves whether this database supports batch updates.

Specified by:
isSupportsBatchUpdates in interface Database
Returns:
true if this database supports batch upcates; false otherwise
Since:
1.2 (JDBC 2.0)

setSupportsBatchUpdates

public void setSupportsBatchUpdates(Boolean supportsBatchUpdates)
Sets whether this database supports batch updates.

Specified by:
setSupportsBatchUpdates in interface Database
Parameters:
supportsBatchUpdates - true if this database supports batch upcates; false otherwise
Since:
1.2 (JDBC 2.0)

getUserDefinedTypes

public Set<UserDefinedType> getUserDefinedTypes()
Retrieves a description of the UDT available in the given catalog.

Specified by:
getUserDefinedTypes in interface Database
Returns:
a set of UDT available

addUserDefinedType

public void addUserDefinedType(UserDefinedType udt)
Adds UDT

Specified by:
addUserDefinedType in interface Database
Parameters:
udt - the UDT to add

deleteUserDefinedType

public void deleteUserDefinedType(UserDefinedType udt)
Deletes UDT

Specified by:
deleteUserDefinedType in interface Database
Parameters:
udt - the UDT to delete

findUserDefinedTypeByName

public UserDefinedType findUserDefinedTypeByName(String catalog,
                                                 String schema,
                                                 String tableName)
Finds UDT by its name.

Specified by:
findUserDefinedTypeByName in interface Database
Parameters:
catalog - a catalog name; must match the catalog name as it is stored in the database; "" retrieves those without a catalog; null means that the catalog name should not be used to narrow the search
schema - a schema name; must match the schema name as it is stored in the database; "" retrieves those without a schema; null means that the schema name should not be used to narrow the search
tableName - a table name; must match the table name as it is stored in the database
Returns:
table or null if not found

isSupportsSavepoints

public Boolean isSupportsSavepoints()
Retrieves whether this database supports savepoints.

Specified by:
isSupportsSavepoints in interface Database
Returns:
true if savepoints are supported; false otherwise
Since:
1.4 (JDBC 3.0)

setSupportsSavepoints

public void setSupportsSavepoints(Boolean supportsSavepoints)
Sets whether this database supports savepoints.

Specified by:
setSupportsSavepoints in interface Database
Parameters:
supportsSavepoints - true if savepoints are supported; false otherwise
Since:
1.4 (JDBC 3.0)

isSupportsNamedParameters

public Boolean isSupportsNamedParameters()
Retrieves whether this database supports named parameters to callable statements.

Specified by:
isSupportsNamedParameters in interface Database
Returns:
true if named parameters are supported; false otherwise
Since:
1.4 (JDBC 3.0)

setSupportsNamedParameters

public void setSupportsNamedParameters(Boolean supportsNamedParameters)
Sets whether this database supports named parameters to callable statements.

Specified by:
setSupportsNamedParameters in interface Database
Parameters:
supportsNamedParameters - true if named parameters are supported; false otherwise
Since:
1.4 (JDBC 3.0)

isSupportsMultipleOpenResults

public Boolean isSupportsMultipleOpenResults()
Retrieves whether it is possible to have multiple ResultSet objects returned from a CallableStatement object simultaneously.

Specified by:
isSupportsMultipleOpenResults in interface Database
Returns:
true if a CallableStatement object can return multiple ResultSet objects simultaneously; false otherwise
Since:
1.4 (JDBC 3.0)

setSupportsMultipleOpenResults

public void setSupportsMultipleOpenResults(Boolean supportsMultipleOpenResults)
Sets whether it is possible to have multiple ResultSet objects returned from a CallableStatement object simultaneously.

Specified by:
setSupportsMultipleOpenResults in interface Database
Parameters:
supportsMultipleOpenResults - true if a CallableStatement object can return multiple ResultSet objects simultaneously; false otherwise
Since:
1.4 (JDBC 3.0)

isSupportsGetGeneratedKeys

public Boolean isSupportsGetGeneratedKeys()
Retrieves whether auto-generated keys can be retrieved after a statement has been executed.

Specified by:
isSupportsGetGeneratedKeys in interface Database
Returns:
true if auto-generated keys can be retrieved after a statement has executed; false otherwise
Since:
1.4 (JDBC 3.0)

setSupportsGetGeneratedKeys

public void setSupportsGetGeneratedKeys(Boolean supportsGetGeneratedKeys)
Sets whether auto-generated keys can be retrieved after a statement has been executed.

Specified by:
setSupportsGetGeneratedKeys in interface Database
Parameters:
supportsGetGeneratedKeys - true if auto-generated keys can be retrieved after a statement has executed; false otherwise
Since:
1.4 (JDBC 3.0)

isSupportsResultSetHoldCurrorsOverCommitHoldability

public Boolean isSupportsResultSetHoldCurrorsOverCommitHoldability()
Retrieves whether this database supports the given result set holdability.

Specified by:
isSupportsResultSetHoldCurrorsOverCommitHoldability in interface Database
Returns:
true if so; false otherwise
Since:
1.4 (JDBC 3.0)
See Also:
Connection

setSupportsResultSetHoldCurrorsOverCommitHoldability

public void setSupportsResultSetHoldCurrorsOverCommitHoldability(Boolean supportsResultSetHoldCurrorsOverCommitHoldability)
Sets whether this database supports the given result set holdability.

Specified by:
setSupportsResultSetHoldCurrorsOverCommitHoldability in interface Database
Parameters:
supportsResultSetHoldCurrorsOverCommitHoldability - true if so; false otherwise
Since:
1.4 (JDBC 3.0)
See Also:
Connection

isSupportsResultSetCloseCurrorsAtCommitHoldability

public Boolean isSupportsResultSetCloseCurrorsAtCommitHoldability()
Retrieves whether this database supports the given result set holdability.

Specified by:
isSupportsResultSetCloseCurrorsAtCommitHoldability in interface Database
Returns:
true if so; false otherwise
Since:
1.4 (JDBC 3.0)
See Also:
Connection

setSupportsResultSetCloseCurrorsAtCommitHoldability

public void setSupportsResultSetCloseCurrorsAtCommitHoldability(Boolean supportsResultSetCloseCurrorsAtCommitHoldability)
Sets whether this database supports the given result set holdability.

Specified by:
setSupportsResultSetCloseCurrorsAtCommitHoldability in interface Database
Parameters:
supportsResultSetCloseCurrorsAtCommitHoldability - true if so; false otherwise
Since:
1.4 (JDBC 3.0)
See Also:
Connection

getResultSetHoldabilityType

public ResultSetHoldabilityType getResultSetHoldabilityType()
Retrieves the default holdability of this ResultSet object.

Specified by:
getResultSetHoldabilityType in interface Database
Returns:
the default holdability; either ResultSet.HOLD_CURSORS_OVER_COMMIT or ResultSet.CLOSE_CURSORS_AT_COMMIT
Since:
1.4

setResultSetHoldabilityType

public void setResultSetHoldabilityType(ResultSetHoldabilityType resultSetHoldabilityType)
Sets the default holdability of this ResultSet object.

Specified by:
setResultSetHoldabilityType in interface Database
Parameters:
resultSetHoldabilityType - the ResultSetHoldabilityType the default holdability; either ResultSet.HOLD_CURSORS_OVER_COMMIT or ResultSet.CLOSE_CURSORS_AT_COMMIT
Since:
1.4

getDatabaseMajorVersion

public Integer getDatabaseMajorVersion()
Retrieves the major version number of the underlying database.

Specified by:
getDatabaseMajorVersion in interface Database
Returns:
the underlying database's major version
Since:
1.4 (JDBC 3.0)

setDatabaseMajorVersion

public void setDatabaseMajorVersion(Integer databaseMajorVersion)
Sets the major version number of the underlying database.

Specified by:
setDatabaseMajorVersion in interface Database
Parameters:
databaseMajorVersion - the underlying database's major version
Since:
1.4 (JDBC 3.0)

getDatabaseMinorVersion

public Integer getDatabaseMinorVersion()
Retrieves the minor version number of the underlying database.

Specified by:
getDatabaseMinorVersion in interface Database
Returns:
underlying database's minor version
Since:
1.4 (JDBC 3.0)

setDatabaseMinorVersion

public void setDatabaseMinorVersion(Integer databaseMinorVersion)
Sets the minor version number of the underlying database.

Specified by:
setDatabaseMinorVersion in interface Database
Parameters:
databaseMinorVersion - underlying database's minor version
Since:
1.4 (JDBC 3.0)

getJDBCMajorVersion

public Integer getJDBCMajorVersion()
Retrieves the major JDBC version number for this driver.

Specified by:
getJDBCMajorVersion in interface Database
Returns:
JDBC version major number
Since:
1.4 (JDBC 3.0)

setJDBCMajorVersion

public void setJDBCMajorVersion(Integer jdbcMajorVersion)
Sets the major JDBC version number for this driver.

Specified by:
setJDBCMajorVersion in interface Database
Parameters:
jdbcMajorVersion - JDBC version major number
Since:
1.4 (JDBC 3.0)

getJDBCMinorVersion

public Integer getJDBCMinorVersion()
Retrieves the minor JDBC version number for this driver.

Specified by:
getJDBCMinorVersion in interface Database
Returns:
JDBC version minor number
Since:
1.4 (JDBC 3.0)

setJDBCMinorVersion

public void setJDBCMinorVersion(Integer jdbcMinorVersion)
Sets the minor JDBC version number for this driver.

Specified by:
setJDBCMinorVersion in interface Database
Parameters:
jdbcMinorVersion - JDBC version minor number
Since:
1.4 (JDBC 3.0)

getSQLStateType

public SQLStateType getSQLStateType()
Indicates whether the SQLSTATE returned by SQLException.getSQLState is X/Open (now known as Open Group) SQL CLI or SQL99.

Specified by:
getSQLStateType in interface Database
Returns:
the type of SQLSTATE; one of: sqlStateXOpen or sqlStateSQL99
Since:
1.4 (JDBC 3.0)

setSQLStateType

public void setSQLStateType(SQLStateType sqlStateType)
Indicates whether the SQLSTATE returned by SQLException.getSQLState is X/Open (now known as Open Group) SQL CLI or SQL99.

Specified by:
setSQLStateType in interface Database
Parameters:
sqlStateType - the type of SQLSTATE; one of: sqlStateXOpen or sqlStateSQL99
Since:
1.4 (JDBC 3.0)

isLocatorsUpdateCopy

public Boolean isLocatorsUpdateCopy()
Indicates whether updates made to a LOB are made on a copy or directly to the LOB.

Specified by:
isLocatorsUpdateCopy in interface Database
Returns:
true if updates are made to a copy of the LOB; false if updates are made directly to the LOB
Since:
1.4 (JDBC 3.0)

setLocatorsUpdateCopy

public void setLocatorsUpdateCopy(Boolean locatorsUpdateCopy)
Indicates whether updates made to a LOB are made on a copy or directly to the LOB.

Specified by:
setLocatorsUpdateCopy in interface Database
Parameters:
locatorsUpdateCopy - true if updates are made to a copy of the LOB; false if updates are made directly to the LOB
Since:
1.4 (JDBC 3.0)

isSupportsStatementPooling

public Boolean isSupportsStatementPooling()
Retrieves whether this database supports statement pooling.

Specified by:
isSupportsStatementPooling in interface Database
Returns:
true if so; false otherwise
Since:
1.4 (JDBC 3.0)

setSupportsStatementPooling

public void setSupportsStatementPooling(Boolean supportsStatementPooling)
Sets whether this database supports statement pooling.

Specified by:
setSupportsStatementPooling in interface Database
Parameters:
supportsStatementPooling - true if so; false otherwise
Since:
1.4 (JDBC 3.0)
Overview  Package   Class  Tree  Deprecated  Index  Help 
 PREV CLASS   NEXT CLASS FRAMES    NO FRAMES    
SUMMARY: NESTED | FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD
Copyright © 2008-Present JBoss a division of Red Hat. All Rights Reserved.