Uses of Class
liquibase.exception.DatabaseException

Packages that use DatabaseException
liquibase   
liquibase.changelog.filter   
liquibase.database   
liquibase.database.core   
liquibase.database.jvm   
liquibase.dbdoc   
liquibase.diff   
liquibase.diff.core   
liquibase.diff.output.changelog   
liquibase.diff.output.report   
liquibase.exception   
liquibase.executor   
liquibase.executor.jvm   
liquibase.integration.cdi   
liquibase.integration.commandline   
liquibase.integration.spring   
liquibase.lockservice   
liquibase.snapshot   
liquibase.snapshot.jvm   
liquibase.statement   
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(CatalogAndSchema... schemas)
          Drops all database objects owned by the current user.
 boolean Liquibase.isSafeToRunUpdate()
          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.database
 

Methods in liquibase.database that throw DatabaseException
protected  boolean AbstractJdbcDatabase.canCreateChangeLogTable()
           
 void AbstractJdbcDatabase.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 AbstractJdbcDatabase.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 AbstractJdbcDatabase.close()
           
 void Database.close()
           
 void DatabaseConnection.close()
           
 void AbstractJdbcDatabase.commit()
           
 void Database.commit()
           
 void DatabaseConnection.commit()
           
 PreparedStatement PreparedStatementFactory.create(String sql)
          Create a PreparedStatement object, sql pre-compilation might take place, depending on driver support.
 boolean AbstractJdbcDatabase.disableForeignKeyChecks()
           
 boolean Database.disableForeignKeyChecks()
           
 boolean AbstractJdbcDatabase.doesTagExist(String tag)
           
 boolean Database.doesTagExist(String tag)
           
protected  String AbstractJdbcDatabase.doGetDefaultCatalogName()
           
 void AbstractJdbcDatabase.enableForeignKeyChecks()
           
 void Database.enableForeignKeyChecks()
           
 Database DatabaseFactory.findCorrectDatabaseImplementation(DatabaseConnection connection)
           
 boolean DatabaseConnection.getAutoCommit()
           
 String DatabaseConnection.getCatalog()
           
 int AbstractJdbcDatabase.getDatabaseMajorVersion()
           
 int Database.getDatabaseMajorVersion()
           
 int DatabaseConnection.getDatabaseMajorVersion()
           
 int AbstractJdbcDatabase.getDatabaseMinorVersion()
           
 int Database.getDatabaseMinorVersion()
           
 int DatabaseConnection.getDatabaseMinorVersion()
           
 String DatabaseConnection.getDatabaseProductName()
           
 String AbstractJdbcDatabase.getDatabaseProductVersion()
           
 String Database.getDatabaseProductVersion()
           
 String DatabaseConnection.getDatabaseProductVersion()
           
 RanChangeSet AbstractJdbcDatabase.getRanChangeSet(ChangeSet changeSet)
           
 RanChangeSet Database.getRanChangeSet(ChangeSet changeSet)
           
 List<RanChangeSet> AbstractJdbcDatabase.getRanChangeSetList()
          Returns the ChangeSets that have been run against the current database.
 List<RanChangeSet> Database.getRanChangeSetList()
           
 Date AbstractJdbcDatabase.getRanDate(ChangeSet changeSet)
           
 Date Database.getRanDate(ChangeSet changeSet)
           
 ChangeSet.RunStatus AbstractJdbcDatabase.getRunStatus(ChangeSet changeSet)
          Returns the run status for the given ChangeSet
 ChangeSet.RunStatus Database.getRunStatus(ChangeSet changeSet)
           
 String AbstractJdbcDatabase.getViewDefinition(CatalogAndSchema schema, String viewName)
           
 String Database.getViewDefinition(CatalogAndSchema schema, String name)
           
 boolean AbstractJdbcDatabase.hasDatabaseChangeLogLockTable()
           
 boolean Database.hasDatabaseChangeLogLockTable()
           
 boolean AbstractJdbcDatabase.hasDatabaseChangeLogTable()
           
 boolean Database.hasDatabaseChangeLogTable()
           
 boolean AbstractJdbcDatabase.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 AbstractJdbcDatabase.isSafeToRunUpdate()
          Default implementation, just look for "local" IPs.
 boolean Database.isSafeToRunUpdate()
           
 void AbstractJdbcDatabase.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 AbstractJdbcDatabase.removeRanStatus(ChangeSet changeSet)
           
 void Database.removeRanStatus(ChangeSet changeSet)
           
 void AbstractJdbcDatabase.rollback()
           
 void Database.rollback()
           
 void DatabaseConnection.rollback()
           
 void AbstractJdbcDatabase.setAutoCommit(boolean b)
           
 void Database.setAutoCommit(boolean b)
           
 void DatabaseConnection.setAutoCommit(boolean autoCommit)
           
 void Database.setDefaultCatalogName(String catalogName)
           
 void Database.setDefaultSchemaName(String schemaName)
           
 void AbstractJdbcDatabase.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 InformixDatabase.checkDatabaseChangeLogTable(boolean updateExistingNullChecksums, DatabaseChangeLog databaseChangeLog, String... contexts)
           
 void DerbyDatabase.close()
           
 boolean MySQLDatabase.disableForeignKeyChecks()
           
protected  String DerbyDatabase.doGetDefaultCatalogName()
           
protected  String HsqlDatabase.doGetDefaultCatalogName()
           
protected  String OracleDatabase.doGetDefaultCatalogName()
           
 void MySQLDatabase.enableForeignKeyChecks()
           
static List<SqlStatement> SQLiteDatabase.getAlterTableStatements(SQLiteDatabase.AlterTableVisitor alterTableVisitor, Database database, String catalogName, String schemaName, String tableName)
           
 int SybaseDatabase.getDatabaseMajorVersion()
           
 int SybaseDatabase.getDatabaseMinorVersion()
           
 String CacheDatabase.getViewDefinition(CatalogAndSchema schema, String viewName)
           
 String DB2Database.getViewDefinition(CatalogAndSchema schema, String name)
           
 String DerbyDatabase.getViewDefinition(CatalogAndSchema schema, String name)
           
 String H2Database.getViewDefinition(CatalogAndSchema schema, String name)
           
 String InformixDatabase.getViewDefinition(CatalogAndSchema schema, String viewName)
           
 String MSSQLDatabase.getViewDefinition(CatalogAndSchema schema, String viewName)
           
 String SQLiteDatabase.getViewDefinition(CatalogAndSchema schema, String viewName)
           
 String SybaseASADatabase.getViewDefinition(CatalogAndSchema schema, String viewName)
           
 String SybaseDatabase.getViewDefinition(CatalogAndSchema schema, 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.isSafeToRunUpdate()
           
 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
 boolean DiffResult.areEqual()
           
 DiffResult DiffGenerator.compare(DatabaseSnapshot referenceSnapshot, DatabaseSnapshot comparisonSnapshot, CompareControl compareControl)
           
 DiffResult DiffGeneratorFactory.compare(DatabaseSnapshot referenceSnapshot, DatabaseSnapshot comparisonSnapshot, CompareControl compareControl)
           
 

Uses of DatabaseException in liquibase.diff.core
 

Methods in liquibase.diff.core that throw DatabaseException
protected  void StandardDiffGenerator.checkVersionInfo(DatabaseSnapshot referenceSnapshot, DatabaseSnapshot comparisonSnapshot, DiffResult diffResult)
           
 DiffResult StandardDiffGenerator.compare(DatabaseSnapshot referenceSnapshot, DatabaseSnapshot comparisonSnapshot, CompareControl compareControl)
           
 

Uses of DatabaseException in liquibase.diff.output.changelog
 

Methods in liquibase.diff.output.changelog that throw DatabaseException
protected  void DiffToChangeLog.addInsertDataChanges(List<ChangeSet> changeSets, String dataDir)
           
 void DiffToChangeLog.print(PrintStream out)
           
 void DiffToChangeLog.print(PrintStream out, ChangeLogSerializer changeLogSerializer)
          Prints changeLog that would bring the target database to be the same as the reference database
 void DiffToChangeLog.print(String changeLogFile)
           
 void DiffToChangeLog.print(String changeLogFile, ChangeLogSerializer changeLogSerializer)
           
 

Uses of DatabaseException in liquibase.diff.output.report
 

Methods in liquibase.diff.output.report that throw DatabaseException
 void DiffToReport.print()
           
 

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)
           
 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
 void JdbcExecutor.comment(String message)
           
 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.cdi
 

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

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 defaultCatalogName, String defaultSchemaName, String databaseClass, String driverPropertiesFile)
           
static void CommandLineUtils.doGenerateChangeLog(String changeLogFile, Database originalDatabase, String catalogName, String schemaName, String snapshotTypes, String author, String context, String dataDir, DiffOutputControl diffOutputControl)
           
 

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
 void LockServiceImpl.forceReleaseLock()
           
 

Uses of DatabaseException in liquibase.snapshot
 

Methods in liquibase.snapshot that throw DatabaseException
 DatabaseSnapshot SnapshotGeneratorFactory.createSnapshot(CatalogAndSchema[] examples, Database database, SnapshotControl snapshotControl)
           
 DatabaseSnapshot SnapshotGeneratorFactory.createSnapshot(CatalogAndSchema example, Database database, SnapshotControl snapshotControl)
           
 DatabaseSnapshot SnapshotGeneratorFactory.createSnapshot(DatabaseObject[] examples, Database database, SnapshotControl snapshotControl)
           
<T extends DatabaseObject>
T
SnapshotGeneratorFactory.createSnapshot(T example, Database database)
           
<T extends DatabaseObject>
T
SnapshotGeneratorFactory.createSnapshot(T example, Database database, SnapshotControl snapshotControl)
           
 Table SnapshotGeneratorFactory.getDatabaseChangeLogLockTable(Database database)
           
 Table SnapshotGeneratorFactory.getDatabaseChangeLogTable(SnapshotControl snapshotControl, Database database)
           
 boolean SnapshotGeneratorFactory.has(DatabaseObject example, Database database)
           
 boolean SnapshotGeneratorFactory.hasDatabaseChangeLogLockTable(Database database)
           
 boolean SnapshotGeneratorFactory.hasDatabaseChangeLogTable(Database database)
           
protected
<T extends DatabaseObject>
T
DatabaseSnapshot.include(T example)
          Include the object described by the passed example object in this snapshot.
<T extends DatabaseObject>
T
SnapshotGeneratorChain.snapshot(T example, DatabaseSnapshot snapshot)
           
<T extends DatabaseObject>
T
SnapshotGenerator.snapshot(T example, DatabaseSnapshot snapshot, SnapshotGeneratorChain chain)
           
 

Uses of DatabaseException in liquibase.snapshot.jvm
 

Methods in liquibase.snapshot.jvm that throw DatabaseException
protected  void CatalogSnapshotGenerator.addTo(DatabaseObject foundObject, DatabaseSnapshot snapshot)
           
protected  void ColumnSnapshotGenerator.addTo(DatabaseObject foundObject, DatabaseSnapshot snapshot)
           
protected  void ForeignKeySnapshotGenerator.addTo(DatabaseObject foundObject, DatabaseSnapshot snapshot)
           
protected  void IndexSnapshotGenerator.addTo(DatabaseObject foundObject, DatabaseSnapshot snapshot)
           
protected abstract  void JdbcSnapshotGenerator.addTo(DatabaseObject foundObject, DatabaseSnapshot snapshot)
           
protected  void PrimaryKeySnapshotGenerator.addTo(DatabaseObject foundObject, DatabaseSnapshot snapshot)
           
protected  void SchemaSnapshotGenerator.addTo(DatabaseObject foundObject, DatabaseSnapshot snapshot)
           
protected  void SequenceSnapshotGenerator.addTo(DatabaseObject foundObject, DatabaseSnapshot snapshot)
           
protected  void TableSnapshotGenerator.addTo(DatabaseObject foundObject, DatabaseSnapshot snapshot)
           
protected  void UniqueConstraintSnapshotGenerator.addTo(DatabaseObject foundObject, DatabaseSnapshot snapshot)
           
protected  void ViewSnapshotGenerator.addTo(DatabaseObject foundObject, DatabaseSnapshot snapshot)
           
protected  ForeignKeyConstraintType ForeignKeySnapshotGenerator.convertToForeignKeyConstraintType(Integer jdbcType, Database database)
           
protected  List<Map> UniqueConstraintSnapshotGenerator.listColumns(UniqueConstraint example, Database database)
           
protected  List<Map> UniqueConstraintSnapshotGenerator.listConstraints(Table table, Database database, Schema schema)
           
protected  Column ColumnSnapshotGenerator.readColumn(JdbcDatabaseSnapshot.CachedRow columnMetadataResultSet, Relation table, Database database)
           
protected  Object ColumnSnapshotGenerator.readDefaultValue(JdbcDatabaseSnapshot.CachedRow columnMetadataResultSet, Column columnInfo, Database database)
           
protected  Object H2ColumnSnapshotGenerator.readDefaultValue(JdbcDatabaseSnapshot.CachedRow columnMetadataResultSet, Column columnInfo, Database database)
           
protected  Table TableSnapshotGenerator.readTable(JdbcDatabaseSnapshot.CachedRow tableMetadataResultSet, Database database)
           
 DatabaseObject JdbcSnapshotGenerator.snapshot(DatabaseObject example, DatabaseSnapshot snapshot, SnapshotGeneratorChain chain)
           
protected  DatabaseObject CatalogSnapshotGenerator.snapshotObject(DatabaseObject example, DatabaseSnapshot snapshot)
           
protected  DatabaseObject ColumnSnapshotGenerator.snapshotObject(DatabaseObject example, DatabaseSnapshot snapshot)
           
protected  DatabaseObject ForeignKeySnapshotGenerator.snapshotObject(DatabaseObject example, DatabaseSnapshot snapshot)
           
protected  DatabaseObject IndexSnapshotGenerator.snapshotObject(DatabaseObject example, DatabaseSnapshot snapshot)
           
protected abstract  DatabaseObject JdbcSnapshotGenerator.snapshotObject(DatabaseObject example, DatabaseSnapshot snapshot)
           
protected  DatabaseObject PrimaryKeySnapshotGenerator.snapshotObject(DatabaseObject example, DatabaseSnapshot snapshot)
           
protected  DatabaseObject SchemaSnapshotGenerator.snapshotObject(DatabaseObject example, DatabaseSnapshot snapshot)
           
protected  DatabaseObject TableSnapshotGenerator.snapshotObject(DatabaseObject example, DatabaseSnapshot snapshot)
           
protected  DatabaseObject UniqueConstraintSnapshotGenerator.snapshotObject(DatabaseObject example, DatabaseSnapshot snapshot)
           
protected  DatabaseObject ViewSnapshotGenerator.snapshotObject(DatabaseObject example, DatabaseSnapshot snapshot)
           
 

Uses of DatabaseException in liquibase.statement
 

Methods in liquibase.statement that throw DatabaseException
 void ExecutablePreparedStatement.execute(PreparedStatementFactory factory)
          Execute the prepared statement
 void ExecutablePreparedStatementBase.execute(PreparedStatementFactory factory)
           
 

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 © 2013 Liquibase.org. All Rights Reserved.