Uses of Class
liquibase.exception.DatabaseException

Packages that use DatabaseException
liquibase   
liquibase.changelog.filter   
liquibase.changelog.visitor   
liquibase.database   
liquibase.database.core   
liquibase.database.jvm   
liquibase.dbdoc   
liquibase.diff   
liquibase.exception   
liquibase.executor   
liquibase.executor.jvm   
liquibase.integration.commandline   
liquibase.integration.spring   
liquibase.lockservice   
liquibase.snapshot   
liquibase.snapshot.jvm   
liquibase.util   
liquibase.util.ui   
 

Uses of DatabaseException in liquibase
 

Methods in liquibase that throw DatabaseException
 void Liquibase.dropAll()
          Drops all database objects owned by the current user.
 void Liquibase.dropAll(String... schemas)
          Drops all database objects owned by the current user.
 boolean Liquibase.isSafeToRunMigration()
          Returns true if it is "save" to migrate the database.
 

Uses of DatabaseException in liquibase.changelog.filter
 

Constructors in liquibase.changelog.filter that throw DatabaseException
ShouldRunChangeSetFilter(Database database)
           
 

Uses of DatabaseException in liquibase.changelog.visitor
 

Methods in liquibase.changelog.visitor that throw DatabaseException
 void DBDocVisitor.writeHTML(File rootOutputDir, ResourceAccessor resourceAccessor)
           
 

Uses of DatabaseException in liquibase.database
 

Methods in liquibase.database that throw DatabaseException
protected  boolean AbstractDatabase.canCreateChangeLogTable()
           
 void AbstractDatabase.checkDatabaseChangeLogLockTable()
          This method will check the database ChangeLogLock table used to keep track of if a machine is updating the database.
 void Database.checkDatabaseChangeLogLockTable()
           
 void AbstractDatabase.checkDatabaseChangeLogTable(boolean updateExistingNullChecksums, DatabaseChangeLog databaseChangeLog, String... contexts)
          This method will check the database ChangeLog table used to keep track of the changes in the file.
 void Database.checkDatabaseChangeLogTable(boolean updateExistingNullChecksums, DatabaseChangeLog databaseChangeLog, String[] contexts)
           
 void AbstractDatabase.close()
           
 void Database.close()
           
 void DatabaseConnection.close()
           
 void AbstractDatabase.commit()
           
 void Database.commit()
           
 void DatabaseConnection.commit()
           
 String AbstractDatabase.convertRequestedSchemaToCatalog(String requestedSchema)
           
 String Database.convertRequestedSchemaToCatalog(String requestedSchema)
           
 String AbstractDatabase.convertRequestedSchemaToSchema(String requestedSchema)
           
 String Database.convertRequestedSchemaToSchema(String requestedSchema)
           
 boolean AbstractDatabase.disableForeignKeyChecks()
           
 boolean Database.disableForeignKeyChecks()
           
 boolean AbstractDatabase.doesTagExist(String tag)
           
 boolean Database.doesTagExist(String tag)
           
 void AbstractDatabase.dropDatabaseObjects(String schema)
          Drops all objects owned by the connected user.
 void Database.dropDatabaseObjects(String schema)
           
 void AbstractDatabase.enableForeignKeyChecks()
           
 void Database.enableForeignKeyChecks()
           
 Database DatabaseFactory.findCorrectDatabaseImplementation(DatabaseConnection connection)
           
 boolean DatabaseConnection.getAutoCommit()
           
 String DatabaseConnection.getCatalog()
           
 int AbstractDatabase.getDatabaseMajorVersion()
           
 int Database.getDatabaseMajorVersion()
           
 int DatabaseConnection.getDatabaseMajorVersion()
           
 int AbstractDatabase.getDatabaseMinorVersion()
           
 int Database.getDatabaseMinorVersion()
           
 int DatabaseConnection.getDatabaseMinorVersion()
           
 String DatabaseConnection.getDatabaseProductName()
           
 String AbstractDatabase.getDatabaseProductVersion()
           
 String Database.getDatabaseProductVersion()
           
 String DatabaseConnection.getDatabaseProductVersion()
           
 String AbstractDatabase.getDefaultCatalogName()
           
 String Database.getDefaultCatalogName()
           
protected  String AbstractDatabase.getDefaultDatabaseSchemaName()
           
 RanChangeSet AbstractDatabase.getRanChangeSet(ChangeSet changeSet)
           
 RanChangeSet Database.getRanChangeSet(ChangeSet changeSet)
           
 List<RanChangeSet> AbstractDatabase.getRanChangeSetList()
          Returns the ChangeSets that have been run against the current database.
 List<RanChangeSet> Database.getRanChangeSetList()
           
 Date AbstractDatabase.getRanDate(ChangeSet changeSet)
           
 Date Database.getRanDate(ChangeSet changeSet)
           
 ChangeSet.RunStatus AbstractDatabase.getRunStatus(ChangeSet changeSet)
          Returns the run status for the given ChangeSet
 ChangeSet.RunStatus Database.getRunStatus(ChangeSet changeSet)
           
 Table AbstractDatabase.getTable(String schemaName, String tableName)
           
 String AbstractDatabase.getViewDefinition(String schemaName, String viewName)
           
 String Database.getViewDefinition(String schemaName, String name)
           
 boolean AbstractDatabase.hasDatabaseChangeLogLockTable()
           
 boolean Database.hasDatabaseChangeLogLockTable()
           
 boolean AbstractDatabase.hasDatabaseChangeLogTable()
           
 boolean Database.hasDatabaseChangeLogTable()
           
 boolean AbstractDatabase.isAutoCommit()
           
 boolean Database.isAutoCommit()
           
 boolean DatabaseConnection.isClosed()
           
 boolean Database.isCorrectDatabaseImplementation(DatabaseConnection conn)
          Is this AbstractDatabase subclass the correct one to use for the given connection.
 boolean AbstractDatabase.isLocalDatabase()
          Default implementation, just look for "local" IPs
 boolean Database.isLocalDatabase()
           
 void AbstractDatabase.markChangeSetExecStatus(ChangeSet changeSet, ChangeSet.ExecType execType)
          After the change set has been ran against the database this method will update the change log table with the information.
 void Database.markChangeSetExecStatus(ChangeSet changeSet, ChangeSet.ExecType execType)
           
 String DatabaseConnection.nativeSQL(String sql)
           
 void AbstractDatabase.removeRanStatus(ChangeSet changeSet)
           
 void Database.removeRanStatus(ChangeSet changeSet)
           
 void AbstractDatabase.rollback()
           
 void Database.rollback()
           
 void DatabaseConnection.rollback()
           
 void AbstractDatabase.setAutoCommit(boolean b)
           
 void Database.setAutoCommit(boolean b)
           
 void DatabaseConnection.setAutoCommit(boolean autoCommit)
           
 void AbstractDatabase.setDefaultSchemaName(String schemaName)
           
 void Database.setDefaultSchemaName(String schemaName)
           
 void AbstractDatabase.tag(String tagString)
          Tags the database changelog with the given string.
 void Database.tag(String tagString)
           
 

Uses of DatabaseException in liquibase.database.core
 

Methods in liquibase.database.core that throw DatabaseException
 void DerbyDatabase.close()
           
 String DB2Database.convertRequestedSchemaToCatalog(String requestedSchema)
           
 String MSSQLDatabase.convertRequestedSchemaToCatalog(String requestedSchema)
           
 String MySQLDatabase.convertRequestedSchemaToCatalog(String requestedSchema)
           
 String PostgresDatabase.convertRequestedSchemaToCatalog(String requestedSchema)
           
 String SybaseASADatabase.convertRequestedSchemaToCatalog(String requestedSchema)
           
 String SybaseDatabase.convertRequestedSchemaToCatalog(String requestedSchema)
           
 String DB2Database.convertRequestedSchemaToSchema(String requestedSchema)
           
 String FirebirdDatabase.convertRequestedSchemaToSchema(String requestedSchema)
           
 String H2Database.convertRequestedSchemaToSchema(String requestedSchema)
           
 String HsqlDatabase.convertRequestedSchemaToSchema(String requestedSchema)
           
 String MSSQLDatabase.convertRequestedSchemaToSchema(String requestedSchema)
           
 String MySQLDatabase.convertRequestedSchemaToSchema(String requestedSchema)
           
 String PostgresDatabase.convertRequestedSchemaToSchema(String requestedSchema)
           
 String SybaseASADatabase.convertRequestedSchemaToSchema(String requestedSchema)
           
 String SybaseDatabase.convertRequestedSchemaToSchema(String requestedSchema)
           
 boolean MySQLDatabase.disableForeignKeyChecks()
           
 void MySQLDatabase.enableForeignKeyChecks()
           
static List<SqlStatement> SQLiteDatabase.getAlterTableStatements(SQLiteDatabase.AlterTableVisitor alterTableVisitor, Database database, String schemaName, String tableName)
           
 int SybaseDatabase.getDatabaseMajorVersion()
           
 int SybaseDatabase.getDatabaseMinorVersion()
           
 String MSSQLDatabase.getDefaultCatalogName()
           
 String PostgresDatabase.getDefaultCatalogName()
           
 String SybaseASADatabase.getDefaultCatalogName()
           
 String SybaseDatabase.getDefaultCatalogName()
           
 String UnsupportedDatabase.getDefaultCatalogName()
          Always returns null or DATABASECHANGELOG table may not be found.
protected  String CacheDatabase.getDefaultDatabaseSchemaName()
           
protected  String DB2Database.getDefaultDatabaseSchemaName()
           
protected  String DerbyDatabase.getDefaultDatabaseSchemaName()
           
protected  String H2Database.getDefaultDatabaseSchemaName()
           
protected  String HsqlDatabase.getDefaultDatabaseSchemaName()
           
protected  String MaxDBDatabase.getDefaultDatabaseSchemaName()
           
protected  String MSSQLDatabase.getDefaultDatabaseSchemaName()
           
protected  String MySQLDatabase.getDefaultDatabaseSchemaName()
           
protected  String OracleDatabase.getDefaultDatabaseSchemaName()
           
protected  String PostgresDatabase.getDefaultDatabaseSchemaName()
           
protected  String SybaseASADatabase.getDefaultDatabaseSchemaName()
           
protected  String SybaseDatabase.getDefaultDatabaseSchemaName()
           
protected  String UnsupportedDatabase.getDefaultDatabaseSchemaName()
          Always returns null or DATABASECHANGELOG table may not be found.
 String CacheDatabase.getViewDefinition(String schemaName, String viewName)
           
 String DB2Database.getViewDefinition(String schemaName, String name)
           
 String DerbyDatabase.getViewDefinition(String schemaName, String name)
           
 String H2Database.getViewDefinition(String schemaName, String name)
           
 String InformixDatabase.getViewDefinition(String schemaName, String viewName)
           
 String MSSQLDatabase.getViewDefinition(String schemaName, String viewName)
           
 String SQLiteDatabase.getViewDefinition(String schemaName, String viewName)
           
 String SybaseASADatabase.getViewDefinition(String schemaName, String viewName)
           
 String SybaseDatabase.getViewDefinition(String schemaName, String viewName)
           
 boolean CacheDatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
           
 boolean DB2Database.isCorrectDatabaseImplementation(DatabaseConnection conn)
           
 boolean DB2iDatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
           
 boolean DerbyDatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
           
 boolean FirebirdDatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
           
 boolean H2Database.isCorrectDatabaseImplementation(DatabaseConnection conn)
           
 boolean HsqlDatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
           
 boolean InformixDatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
           
 boolean MaxDBDatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
           
 boolean MSSQLDatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
           
 boolean MySQLDatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
           
 boolean OracleDatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
           
 boolean PostgresDatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
           
 boolean SQLiteDatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
           
 boolean SybaseASADatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
           
 boolean SybaseDatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
           
 boolean UnsupportedDatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
           
 boolean H2Database.isLocalDatabase()
           
 void SybaseASADatabase.setAutoCommit(boolean b)
           
 

Uses of DatabaseException in liquibase.database.jvm
 

Methods in liquibase.database.jvm that throw DatabaseException
 void JdbcConnection.clearWarnings()
           
 void JdbcConnection.close()
           
 void DerbyConnection.commit()
           
 void HsqlConnection.commit()
           
 void JdbcConnection.commit()
           
 void SybaseConnection.commit()
           
 Statement JdbcConnection.createStatement()
           
 Statement JdbcConnection.createStatement(int resultSetType, int resultSetConcurrency)
           
 Statement JdbcConnection.createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability)
           
 boolean JdbcConnection.getAutoCommit()
           
 String JdbcConnection.getCatalog()
           
 int JdbcConnection.getDatabaseMajorVersion()
           
 int JdbcConnection.getDatabaseMinorVersion()
           
 String JdbcConnection.getDatabaseProductName()
           
 String JdbcConnection.getDatabaseProductVersion()
           
 int JdbcConnection.getHoldability()
           
 DatabaseMetaData JdbcConnection.getMetaData()
           
 int JdbcConnection.getTransactionIsolation()
           
 Map<String,Class<?>> JdbcConnection.getTypeMap()
           
 SQLWarning JdbcConnection.getWarnings()
           
 boolean JdbcConnection.isClosed()
           
 boolean JdbcConnection.isReadOnly()
           
 String JdbcConnection.nativeSQL(String sql)
           
 CallableStatement JdbcConnection.prepareCall(String sql)
           
 CallableStatement JdbcConnection.prepareCall(String sql, int resultSetType, int resultSetConcurrency)
           
 CallableStatement JdbcConnection.prepareCall(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability)
           
 PreparedStatement JdbcConnection.prepareStatement(String sql)
           
 PreparedStatement JdbcConnection.prepareStatement(String sql, int autoGeneratedKeys)
           
 PreparedStatement JdbcConnection.prepareStatement(String sql, int[] columnIndexes)
           
 PreparedStatement JdbcConnection.prepareStatement(String sql, int resultSetType, int resultSetConcurrency)
           
 PreparedStatement JdbcConnection.prepareStatement(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability)
           
 PreparedStatement JdbcConnection.prepareStatement(String sql, String[] columnNames)
           
 void JdbcConnection.releaseSavepoint(Savepoint savepoint)
           
 void DerbyConnection.rollback()
           
 void HsqlConnection.rollback()
           
 void JdbcConnection.rollback()
           
 void SybaseConnection.rollback()
           
 void JdbcConnection.rollback(Savepoint savepoint)
           
 void SybaseConnection.rollback(Savepoint savepoint)
           
 void JdbcConnection.setAutoCommit(boolean autoCommit)
           
 void JdbcConnection.setCatalog(String catalog)
           
 void JdbcConnection.setHoldability(int holdability)
           
 void JdbcConnection.setReadOnly(boolean readOnly)
           
 Savepoint JdbcConnection.setSavepoint()
           
 Savepoint JdbcConnection.setSavepoint(String name)
           
 void JdbcConnection.setTransactionIsolation(int level)
           
 void JdbcConnection.setTypeMap(Map<String,Class<?>> map)
           
 

Uses of DatabaseException in liquibase.dbdoc
 

Methods in liquibase.dbdoc that throw DatabaseException
protected  void HTMLWriter.writeBody(FileWriter fileWriter, Object object, List<Change> ranChanges, List<Change> changesToRun)
           
protected  void PendingChangesWriter.writeBody(FileWriter fileWriter, Object object, List<Change> ranChanges, List<Change> changesToRun)
           
protected  void PendingSQLWriter.writeBody(FileWriter fileWriter, Object object, List<Change> ranChanges, List<Change> changesToRun)
           
protected  void RecentChangesWriter.writeBody(FileWriter fileWriter, Object object, List<Change> ranChanges, List<Change> changesToRun)
           
protected  void HTMLWriter.writeChanges(String title, FileWriter fileWriter, List<Change> changes)
           
 void HTMLWriter.writeHTML(Object object, List<Change> ranChanges, List<Change> changesToRun, String changeLog)
           
 

Uses of DatabaseException in liquibase.diff
 

Methods in liquibase.diff that throw DatabaseException
 DiffResult Diff.compare()
           
 boolean DiffResult.differencesFound()
           
 void DiffResult.printChangeLog(PrintStream out, Database targetDatabase)
           
 void DiffResult.printChangeLog(PrintStream out, Database targetDatabase, ChangeLogSerializer changeLogSerializer)
          Prints changeLog that would bring the target database to be the same as the reference database
 void DiffResult.printChangeLog(String changeLogFile, Database targetDatabase)
           
 void DiffResult.printChangeLog(String changeLogFile, Database targetDatabase, ChangeLogSerializer changeLogSerializer)
           
 void DiffResult.printResult(PrintStream out)
           
 

Constructors in liquibase.diff that throw DatabaseException
Diff(Database originalDatabase, String schema)
           
 

Uses of DatabaseException in liquibase.exception
 

Subclasses of DatabaseException in liquibase.exception
 class StatementNotSupportedOnDatabaseException
           
 

Uses of DatabaseException in liquibase.executor
 

Methods in liquibase.executor that throw DatabaseException
protected  String[] AbstractExecutor.applyVisitors(SqlStatement statement, List<SqlVisitor> sqlVisitors)
           
 Map Executor.call(CallableSqlStatement csc, List declaredParameters, List<SqlVisitor> sqlVisitors)
           
 Map LoggingExecutor.call(CallableSqlStatement csc, List declaredParameters, List<SqlVisitor> sqlVisitors)
           
 void Executor.comment(String message)
          Adds a comment to the database.
 void LoggingExecutor.comment(String message)
           
 void Executor.execute(SqlStatement sql)
          Write methods
 void LoggingExecutor.execute(SqlStatement sql)
           
 void Executor.execute(SqlStatement sql, List<SqlVisitor> sqlVisitors)
           
 void LoggingExecutor.execute(SqlStatement sql, List<SqlVisitor> sqlVisitors)
           
 int Executor.queryForInt(SqlStatement sql)
           
 int LoggingExecutor.queryForInt(SqlStatement sql)
           
 int Executor.queryForInt(SqlStatement sql, List<SqlVisitor> sqlVisitors)
           
 int LoggingExecutor.queryForInt(SqlStatement sql, List<SqlVisitor> sqlVisitors)
           
 List<Map> Executor.queryForList(SqlStatement sql)
           
 List<Map> LoggingExecutor.queryForList(SqlStatement sql)
           
 List Executor.queryForList(SqlStatement sql, Class elementType)
           
 List LoggingExecutor.queryForList(SqlStatement sql, Class elementType)
           
 List Executor.queryForList(SqlStatement sql, Class elementType, List<SqlVisitor> sqlVisitors)
           
 List LoggingExecutor.queryForList(SqlStatement sql, Class elementType, List<SqlVisitor> sqlVisitors)
           
 List<Map> Executor.queryForList(SqlStatement sql, List<SqlVisitor> sqlVisitors)
           
 List<Map> LoggingExecutor.queryForList(SqlStatement sql, List<SqlVisitor> sqlVisitors)
           
 long Executor.queryForLong(SqlStatement sql)
           
 long LoggingExecutor.queryForLong(SqlStatement sql)
           
 long Executor.queryForLong(SqlStatement sql, List<SqlVisitor> sqlVisitors)
           
 long LoggingExecutor.queryForLong(SqlStatement sql, List<SqlVisitor> sqlVisitors)
           
 Object Executor.queryForObject(SqlStatement sql, Class requiredType)
          Read methods
 Object LoggingExecutor.queryForObject(SqlStatement sql, Class requiredType)
           
 Object Executor.queryForObject(SqlStatement sql, Class requiredType, List<SqlVisitor> sqlVisitors)
           
 Object LoggingExecutor.queryForObject(SqlStatement sql, Class requiredType, List<SqlVisitor> sqlVisitors)
           
 int Executor.update(SqlStatement sql)
           
 int LoggingExecutor.update(SqlStatement sql)
           
 int Executor.update(SqlStatement sql, List<SqlVisitor> sqlVisitors)
           
 int LoggingExecutor.update(SqlStatement sql, List<SqlVisitor> sqlVisitors)
           
 

Uses of DatabaseException in liquibase.executor.jvm
 

Methods in liquibase.executor.jvm that throw DatabaseException
 Map JdbcExecutor.call(CallableSqlStatement csc, List declaredParameters, List<SqlVisitor> sqlVisitors)
           
 void JdbcExecutor.comment(String message)
           
 Object JdbcExecutor.execute(CallableSqlStatement csc, liquibase.executor.jvm.CallableStatementCallback action, List<SqlVisitor> sqlVisitors)
           
 void JdbcExecutor.execute(SqlStatement sql)
           
 void JdbcExecutor.execute(SqlStatement sql, List<SqlVisitor> sqlVisitors)
           
 Object JdbcExecutor.execute(liquibase.executor.jvm.StatementCallback action, List<SqlVisitor> sqlVisitors)
           
 Object JdbcExecutor.query(SqlStatement sql, liquibase.executor.jvm.ResultSetExtractor rse)
           
 Object JdbcExecutor.query(SqlStatement sql, liquibase.executor.jvm.ResultSetExtractor rse, List<SqlVisitor> sqlVisitors)
           
 List JdbcExecutor.query(SqlStatement sql, RowMapper rowMapper)
           
 List JdbcExecutor.query(SqlStatement sql, RowMapper rowMapper, List<SqlVisitor> sqlVisitors)
           
 int JdbcExecutor.queryForInt(SqlStatement sql)
           
 int JdbcExecutor.queryForInt(SqlStatement sql, List<SqlVisitor> sqlVisitors)
           
 List<Map> JdbcExecutor.queryForList(SqlStatement sql)
           
 List JdbcExecutor.queryForList(SqlStatement sql, Class elementType)
           
 List JdbcExecutor.queryForList(SqlStatement sql, Class elementType, List<SqlVisitor> sqlVisitors)
           
 List<Map> JdbcExecutor.queryForList(SqlStatement sql, List<SqlVisitor> sqlVisitors)
           
 long JdbcExecutor.queryForLong(SqlStatement sql)
           
 long JdbcExecutor.queryForLong(SqlStatement sql, List<SqlVisitor> sqlVisitors)
           
 Object JdbcExecutor.queryForObject(SqlStatement sql, Class requiredType)
           
 Object JdbcExecutor.queryForObject(SqlStatement sql, Class requiredType, List<SqlVisitor> sqlVisitors)
           
 Object JdbcExecutor.queryForObject(SqlStatement sql, RowMapper rowMapper)
           
 Object JdbcExecutor.queryForObject(SqlStatement sql, RowMapper rowMapper, List<SqlVisitor> sqlVisitors)
           
 int JdbcExecutor.update(SqlStatement sql)
           
 int JdbcExecutor.update(SqlStatement sql, List<SqlVisitor> sqlVisitors)
           
 

Uses of DatabaseException in liquibase.integration.commandline
 

Methods in liquibase.integration.commandline that throw DatabaseException
static Database CommandLineUtils.createDatabaseObject(ClassLoader classLoader, String url, String username, String password, String driver, String defaultSchemaName, String databaseClass, String driverPropertiesFile)
           
static void CommandLineUtils.doDiff(Database referenceDatabase, Database targetDatabase)
           
static void CommandLineUtils.doDiffToChangeLog(String changeLogFile, Database referenceDatabase, Database targetDatabase)
           
static void CommandLineUtils.doGenerateChangeLog(String changeLogFile, Database originalDatabase, String defaultSchemaName, String diffTypes, String author, String context, String dataDir)
           
 

Uses of DatabaseException in liquibase.integration.spring
 

Methods in liquibase.integration.spring that throw DatabaseException
protected  Database SpringLiquibase.createDatabase(Connection c)
          Subclasses may override this method add change some database settings such as default schema before returning the database object.
 String SpringLiquibase.getDatabaseProductName()
           
 

Uses of DatabaseException in liquibase.lockservice
 

Methods in liquibase.lockservice that throw DatabaseException
 void LockService.forceReleaseLock()
          Releases whatever locks are on the database change log table
 

Uses of DatabaseException in liquibase.snapshot
 

Methods in liquibase.snapshot that throw DatabaseException
 DatabaseSnapshot DatabaseSnapshotGenerator.createSnapshot(Database database, String schema, Set<DiffStatusListener> listeners)
           
 DatabaseSnapshot DatabaseSnapshotGeneratorFactory.createSnapshot(Database database, String schema, Set<DiffStatusListener> listeners)
          Get generator for database with highest priority.
 Column DatabaseSnapshotGenerator.getColumn(String schemaName, String tableName, String columnName, Database database)
           
 Table DatabaseSnapshotGenerator.getDatabaseChangeLogLockTable(Database database)
           
 Table DatabaseSnapshotGenerator.getDatabaseChangeLogTable(Database database)
           
 ForeignKey DatabaseSnapshotGenerator.getForeignKeyByForeignKeyTable(String schemaName, String tableName, String fkName, Database database)
           
 List<ForeignKey> DatabaseSnapshotGenerator.getForeignKeys(String schemaName, String tableName, Database database)
           
 Table DatabaseSnapshotGenerator.getTable(String schemaName, String tableName, Database database)
           
 boolean DatabaseSnapshotGenerator.hasIndex(String schemaName, String tableName, String indexName, Database database, String columnNames)
           
 

Uses of DatabaseException in liquibase.snapshot.jvm
 

Methods in liquibase.snapshot.jvm that throw DatabaseException
protected  ForeignKeyConstraintType JdbcDatabaseSnapshotGenerator.convertToForeignKeyConstraintType(int jdbcType)
           
protected  ForeignKeyConstraintType MSSQLDatabaseSnapshotGenerator.convertToForeignKeyConstraintType(int jdbcType)
          The sp_fkeys stored procedure spec says that returned integer values of 0, 1 and 2 translate to cascade, noAction and SetNull, which are not the values in the JDBC standard.
 DatabaseSnapshot JdbcDatabaseSnapshotGenerator.createSnapshot(Database database, String requestedSchema, Set<DiffStatusListener> listeners)
           
protected  ForeignKeyInfo JdbcDatabaseSnapshotGenerator.fillForeignKeyInfo(ResultSet rs)
          Fill foreign key information from the current register of a getImportedKeys resultset
protected  ForeignKeyInfo MySQLDatabaseSnapshotGenerator.fillForeignKeyInfo(ResultSet rs)
           
 ForeignKey JdbcDatabaseSnapshotGenerator.generateForeignKey(ForeignKeyInfo fkInfo, Database database, List<ForeignKey> fkList)
          Generation of Foreign Key based on information about it.
 List<ForeignKey> JdbcDatabaseSnapshotGenerator.getAdditionalForeignKeys(String schemaName, Database database)
          It finds only all database-specific Foreign Keys.
 List<ForeignKey> OracleDatabaseSnapshotGenerator.getAdditionalForeignKeys(String schemaName, Database database)
           
 Column JdbcDatabaseSnapshotGenerator.getColumn(String schemaName, String tableName, String columnName, Database database)
           
protected  void InformixDatabaseSnapshotGenerator.getColumnTypeAndDefValue(Column columnInfo, ResultSet rs, Database database)
           
protected  void JdbcDatabaseSnapshotGenerator.getColumnTypeAndDefValue(Column columnInfo, ResultSet rs, Database database)
          Method assigns correct column type and default value to Column object.
protected  void MySQLDatabaseSnapshotGenerator.getColumnTypeAndDefValue(Column columnInfo, ResultSet rs, Database database)
          MySQL specific implementation
protected  void OracleDatabaseSnapshotGenerator.getColumnTypeAndDefValue(Column columnInfo, ResultSet rs, Database database)
          Oracle specific implementation
 Table JdbcDatabaseSnapshotGenerator.getDatabaseChangeLogLockTable(Database database)
           
 Table JdbcDatabaseSnapshotGenerator.getDatabaseChangeLogTable(Database database)
           
 ForeignKey JdbcDatabaseSnapshotGenerator.getForeignKeyByForeignKeyTable(String schemaName, String foreignKeyTableName, String fkName, Database database)
           
 List<ForeignKey> InformixDatabaseSnapshotGenerator.getForeignKeys(String schemaName, String foreignKeyTableName, Database database)
           
 List<ForeignKey> JdbcDatabaseSnapshotGenerator.getForeignKeys(String schemaName, String foreignKeyTableName, Database database)
           
 Table H2DatabaseSnapshotGenerator.getTable(String schemaName, String tableName, Database database)
           
 Table JdbcDatabaseSnapshotGenerator.getTable(String schemaName, String tableName, Database database)
           
 boolean DerbyDatabaseSnapshotGenerator.hasIndex(String schemaName, String tableName, String indexName, Database database, String columnNames)
          Derby seems to have troubles
 boolean JdbcDatabaseSnapshotGenerator.hasIndex(String schemaName, String tableName, String indexName, Database database, String columnNames)
           
 boolean DB2DatabaseSnapshotGenerator.isColumnAutoIncrement(Database database, String schemaName, String tableName, String columnName)
           
 boolean JdbcDatabaseSnapshotGenerator.isColumnAutoIncrement(Database database, String schemaName, String tableName, String columnName)
           
protected  void JdbcDatabaseSnapshotGenerator.readColumns(DatabaseSnapshot snapshot, String schema, DatabaseMetaData databaseMetaData)
           
protected  void OracleDatabaseSnapshotGenerator.readColumns(DatabaseSnapshot snapshot, String schema, DatabaseMetaData databaseMetaData)
           
protected  void SQLiteDatabaseSnapshotGenerator.readColumns(DatabaseSnapshot snapshot, String schema, DatabaseMetaData databaseMetaData)
           
protected  void JdbcDatabaseSnapshotGenerator.readForeignKeyInformation(DatabaseSnapshot snapshot, String schema, DatabaseMetaData databaseMetaData)
           
protected  void SQLiteDatabaseSnapshotGenerator.readForeignKeyInformation(DatabaseSnapshot snapshot, String schema, DatabaseMetaData databaseMetaData)
          SQLite specific implementation
protected  void JdbcDatabaseSnapshotGenerator.readIndexes(DatabaseSnapshot snapshot, String schema, DatabaseMetaData databaseMetaData)
           
protected  void OracleDatabaseSnapshotGenerator.readIndexes(DatabaseSnapshot snapshot, String schema, DatabaseMetaData databaseMetaData)
           
protected  void SQLiteDatabaseSnapshotGenerator.readIndexes(DatabaseSnapshot snapshot, String schema, DatabaseMetaData databaseMetaData)
           
protected  void JdbcDatabaseSnapshotGenerator.readPrimaryKeys(DatabaseSnapshot snapshot, String schema, DatabaseMetaData databaseMetaData)
           
protected  void OracleDatabaseSnapshotGenerator.readPrimaryKeys(DatabaseSnapshot snapshot, String schema, DatabaseMetaData databaseMetaData)
           
protected  void SQLiteDatabaseSnapshotGenerator.readPrimaryKeys(DatabaseSnapshot snapshot, String schema, DatabaseMetaData databaseMetaData)
          SQLite specific implementation
protected  void JdbcDatabaseSnapshotGenerator.readSequences(DatabaseSnapshot snapshot, String schema, DatabaseMetaData databaseMetaData)
           
protected  void SQLiteDatabaseSnapshotGenerator.readSequences(DatabaseSnapshot snapshot, String schema, DatabaseMetaData databaseMetaData)
           
protected  void JdbcDatabaseSnapshotGenerator.readTables(DatabaseSnapshot snapshot, String schema, DatabaseMetaData databaseMetaData)
           
protected  void SQLiteDatabaseSnapshotGenerator.readTables(DatabaseSnapshot snapshot, String schema, DatabaseMetaData databaseMetaData)
           
protected  void JdbcDatabaseSnapshotGenerator.readUniqueConstraints(DatabaseSnapshot snapshot, String schema, DatabaseMetaData databaseMetaData)
           
protected  void OracleDatabaseSnapshotGenerator.readUniqueConstraints(DatabaseSnapshot snapshot, String schema, DatabaseMetaData databaseMetaData)
           
protected  void PostgresDatabaseSnapshotGenerator.readUniqueConstraints(DatabaseSnapshot snapshot, String schema, DatabaseMetaData databaseMetaData)
           
protected  void JdbcDatabaseSnapshotGenerator.readViews(DatabaseSnapshot snapshot, String schema, DatabaseMetaData databaseMetaData)
           
protected  void SQLiteDatabaseSnapshotGenerator.readViews(DatabaseSnapshot snapshot, String schema, DatabaseMetaData databaseMetaData)
           
 

Uses of DatabaseException in liquibase.util
 

Methods in liquibase.util that throw DatabaseException
static Object JdbcUtils.requiredSingleResult(Collection results)
          Return a single result object from the given Collection.
 

Uses of DatabaseException in liquibase.util.ui
 

Methods in liquibase.util.ui that throw DatabaseException
 boolean SwingUIFacade.promptForNonLocalDatabase(Database database)
          Displays swing-based dialog about running against a non-localhost database.
 boolean UIFacade.promptForNonLocalDatabase(Database database)
           
 



Copyright © 2012 Liquibase.org. All Rights Reserved.