Uses of Class
liquibase.exception.DatabaseException

Packages that use DatabaseException
liquibase   
liquibase.changelog   
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.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.
 void Liquibase.generateChangeLog(CatalogAndSchema catalogAndSchema, DiffToChangeLog changeLogWriter, PrintStream outputStream, Class<? extends DatabaseObject>... snapshotTypes)
           
protected  ChangeLogIterator Liquibase.getStandardChangelogIterator(Contexts contexts, DatabaseChangeLog changeLog)
           
 boolean Liquibase.isSafeToRunUpdate()
          Returns true if it is "save" to migrate the database.
 

Uses of DatabaseException in liquibase.changelog
 

Methods in liquibase.changelog that throw DatabaseException
protected  void OfflineChangeLogHistoryService.appendChangeSet(ChangeSet changeSet, ChangeSet.ExecType execType)
           
 boolean StandardChangeLogHistoryService.canCreateChangeLogTable()
           
 void ChangeLogHistoryService.destroy()
           
 void OfflineChangeLogHistoryService.destroy()
           
 void StandardChangeLogHistoryService.destroy()
           
 RanChangeSet AbstractChangeLogHistoryService.getRanChangeSet(ChangeSet changeSet)
           
 RanChangeSet ChangeLogHistoryService.getRanChangeSet(ChangeSet changeSet)
           
 RanChangeSet StandardChangeLogHistoryService.getRanChangeSet(ChangeSet changeSet)
           
 List<RanChangeSet> ChangeLogHistoryService.getRanChangeSets()
           
 List<RanChangeSet> OfflineChangeLogHistoryService.getRanChangeSets()
           
 List<RanChangeSet> StandardChangeLogHistoryService.getRanChangeSets()
          Returns the ChangeSets that have been run against the current getDatabase().
 Date AbstractChangeLogHistoryService.getRanDate(ChangeSet changeSet)
           
 Date ChangeLogHistoryService.getRanDate(ChangeSet changeSet)
          Returns the date the given changeSet was ran.
 ChangeSet.RunStatus AbstractChangeLogHistoryService.getRunStatus(ChangeSet changeSet)
           
 ChangeSet.RunStatus ChangeLogHistoryService.getRunStatus(ChangeSet changeSet)
           
 boolean StandardChangeLogHistoryService.hasDatabaseChangeLogTable()
           
 void ChangeLogHistoryService.init()
          Ensures the change log history container is correctly initialized for use.
 void OfflineChangeLogHistoryService.init()
           
 void StandardChangeLogHistoryService.init()
           
 void ChangeLogHistoryService.removeFromHistory(ChangeSet changeSet)
           
 void OfflineChangeLogHistoryService.removeFromHistory(ChangeSet changeSet)
           
 void StandardChangeLogHistoryService.removeFromHistory(ChangeSet changeSet)
           
protected  void OfflineChangeLogHistoryService.replaceChangeSet(ChangeSet changeSet, liquibase.changelog.OfflineChangeLogHistoryService.ReplaceChangeSetLogic replaceLogic)
           
protected abstract  void AbstractChangeLogHistoryService.replaceChecksum(ChangeSet changeSet)
           
protected  void OfflineChangeLogHistoryService.replaceChecksum(ChangeSet changeSet)
           
protected  void StandardChangeLogHistoryService.replaceChecksum(ChangeSet changeSet)
           
 void ChangeLogHistoryService.setExecType(ChangeSet changeSet, ChangeSet.ExecType execType)
           
 void OfflineChangeLogHistoryService.setExecType(ChangeSet changeSet, ChangeSet.ExecType execType)
           
 void StandardChangeLogHistoryService.setExecType(ChangeSet changeSet, ChangeSet.ExecType execType)
           
 void ChangeLogHistoryService.tag(String tagString)
           
 void OfflineChangeLogHistoryService.tag(String tagString)
           
 void StandardChangeLogHistoryService.tag(String tagString)
          Tags the database changelog with the given string.
 boolean ChangeLogHistoryService.tagExists(String tag)
           
 boolean OfflineChangeLogHistoryService.tagExists(String tag)
           
 boolean StandardChangeLogHistoryService.tagExists(String tag)
           
 void AbstractChangeLogHistoryService.upgradeChecksums(DatabaseChangeLog databaseChangeLog, Contexts contexts)
           
 void ChangeLogHistoryService.upgradeChecksums(DatabaseChangeLog databaseChangeLog, Contexts contexts)
          Upgrades any existing checksums with an out of date version
 void StandardChangeLogHistoryService.upgradeChecksums(DatabaseChangeLog databaseChangeLog, Contexts contexts)
           
 

Uses of DatabaseException in liquibase.changelog.filter
 

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

Uses of DatabaseException in liquibase.database
 

Methods in liquibase.database that throw DatabaseException
protected  boolean AbstractJdbcDatabase.canCreateChangeLogTable()
           
 void AbstractJdbcDatabase.close()
           
 void Database.close()
           
 void DatabaseConnection.close()
           
 void OfflineConnection.close()
           
 void AbstractJdbcDatabase.commit()
           
 void Database.commit()
           
 void DatabaseConnection.commit()
           
 void OfflineConnection.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)
           
 void AbstractJdbcDatabase.enableForeignKeyChecks()
           
 void Database.enableForeignKeyChecks()
           
 Database DatabaseFactory.findCorrectDatabaseImplementation(DatabaseConnection connection)
           
 boolean DatabaseConnection.getAutoCommit()
           
 boolean OfflineConnection.getAutoCommit()
           
 String DatabaseConnection.getCatalog()
           
 String OfflineConnection.getCatalog()
           
protected  String AbstractJdbcDatabase.getConnectionCatalogName()
           
 int AbstractJdbcDatabase.getDatabaseMajorVersion()
           
 int Database.getDatabaseMajorVersion()
           
 int DatabaseConnection.getDatabaseMajorVersion()
           
 int OfflineConnection.getDatabaseMajorVersion()
           
 int AbstractJdbcDatabase.getDatabaseMinorVersion()
           
 int Database.getDatabaseMinorVersion()
           
 int DatabaseConnection.getDatabaseMinorVersion()
           
 int OfflineConnection.getDatabaseMinorVersion()
           
 String DatabaseConnection.getDatabaseProductName()
           
 String OfflineConnection.getDatabaseProductName()
           
 String AbstractJdbcDatabase.getDatabaseProductVersion()
           
 String Database.getDatabaseProductVersion()
           
 String DatabaseConnection.getDatabaseProductVersion()
           
 String OfflineConnection.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.isAutoCommit()
           
 boolean Database.isAutoCommit()
           
 boolean DatabaseConnection.isClosed()
           
 boolean OfflineConnection.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)
           
 String OfflineConnection.nativeSQL(String sql)
           
 DatabaseConnection DatabaseFactory.openConnection(String url, String username, String password, ResourceAccessor resourceAccessor)
           
 DatabaseConnection DatabaseFactory.openConnection(String url, String username, String password, String driver, String databaseClass, String driverPropertiesFile, ResourceAccessor resourceAccessor)
           
 Database DatabaseFactory.openDatabase(String url, String username, String password, ResourceAccessor resourceAccessor)
           
 Database DatabaseFactory.openDatabase(String url, String username, String password, String driver, String databaseClass, String driverPropertiesFile, ResourceAccessor resourceAccessor)
           
 void AbstractJdbcDatabase.removeRanStatus(ChangeSet changeSet)
           
 void Database.removeRanStatus(ChangeSet changeSet)
           
 void AbstractJdbcDatabase.rollback()
           
 void Database.rollback()
           
 void DatabaseConnection.rollback()
           
 void OfflineConnection.rollback()
           
 void AbstractJdbcDatabase.setAutoCommit(boolean b)
           
 void Database.setAutoCommit(boolean b)
           
 void DatabaseConnection.setAutoCommit(boolean autoCommit)
           
 void OfflineConnection.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 DerbyDatabase.close()
           
 boolean MySQLDatabase.disableForeignKeyChecks()
           
 void MySQLDatabase.enableForeignKeyChecks()
           
static List<SqlStatement> SQLiteDatabase.getAlterTableStatements(SQLiteDatabase.AlterTableVisitor alterTableVisitor, Database database, String catalogName, String schemaName, String tableName)
           
protected  String DerbyDatabase.getConnectionCatalogName()
           
protected  String HsqlDatabase.getConnectionCatalogName()
           
protected  String OracleDatabase.getConnectionCatalogName()
           
 int SybaseDatabase.getDatabaseMajorVersion()
           
 int SybaseDatabase.getDatabaseMinorVersion()
           
 int MySQLDatabase.getDatabasePatchVersion()
           
 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 DB2Database.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 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
 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<String,?>> Executor.queryForList(SqlStatement sql)
           
 List<Map<String,?>> 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<String,?>> Executor.queryForList(SqlStatement sql, List<SqlVisitor> sqlVisitors)
           
 List<Map<String,?>> 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)
           
<T> T
Executor.queryForObject(SqlStatement sql, Class<T> requiredType)
          Read methods
<T> T
LoggingExecutor.queryForObject(SqlStatement sql, Class<T> requiredType)
           
<T> T
Executor.queryForObject(SqlStatement sql, Class<T> requiredType, List<SqlVisitor> sqlVisitors)
           
<T> T
LoggingExecutor.queryForObject(SqlStatement sql, Class<T> 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)
           
 Object JdbcExecutor.execute(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<String,?>> JdbcExecutor.queryForList(SqlStatement sql)
           
 List JdbcExecutor.queryForList(SqlStatement sql, Class elementType)
           
 List JdbcExecutor.queryForList(SqlStatement sql, Class elementType, List<SqlVisitor> sqlVisitors)
           
 List<Map<String,?>> JdbcExecutor.queryForList(SqlStatement sql, List<SqlVisitor> sqlVisitors)
           
 long JdbcExecutor.queryForLong(SqlStatement sql)
           
 long JdbcExecutor.queryForLong(SqlStatement sql, List<SqlVisitor> sqlVisitors)
           
<T> T
JdbcExecutor.queryForObject(SqlStatement sql, Class<T> requiredType)
           
<T> T
JdbcExecutor.queryForObject(SqlStatement sql, Class<T> 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 defaultCatalogName, String defaultSchemaName, boolean outputDefaultCatalog, boolean outputDefaultSchema, String databaseClass, String driverPropertiesFile, String liquibaseCatalogName, String liquibaseSchemaName)
           
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.destroy()
           
 void OfflineLockService.destroy()
           
 void StandardLockService.destroy()
           
 void LockService.forceReleaseLock()
          Releases whatever locks are on the database change log table
 void OfflineLockService.forceReleaseLock()
           
 void StandardLockService.forceReleaseLock()
           
 boolean StandardLockService.hasDatabaseChangeLogLockTable()
           
 void LockService.init()
           
 void OfflineLockService.init()
           
 void StandardLockService.init()
           
 boolean StandardLockService.isDatabaseChangeLogLockTableInitialized(boolean tableJustCreated)
           
 

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)
           
 List<CachedRow> JdbcDatabaseSnapshot.CachingDatabaseMetaData.getColumns(String catalogName, String schemaName, String tableName, String columnName)
          Return the columns for the given catalog, schema, table, and column.
 Table SnapshotGeneratorFactory.getDatabaseChangeLogLockTable(Database database)
           
 Table SnapshotGeneratorFactory.getDatabaseChangeLogTable(SnapshotControl snapshotControl, Database database)
           
 List<CachedRow> JdbcDatabaseSnapshot.CachingDatabaseMetaData.getForeignKeys(String catalogName, String schemaName, String tableName, String fkName)
           
 List<CachedRow> JdbcDatabaseSnapshot.CachingDatabaseMetaData.getIndexInfo(String catalogName, String schemaName, String tableName, String indexName)
           
 List<CachedRow> JdbcDatabaseSnapshot.CachingDatabaseMetaData.getPrimaryKeys(String catalogName, String schemaName, String table)
           
 List<CachedRow> JdbcDatabaseSnapshot.CachingDatabaseMetaData.getTables(String catalogName, String schemaName, String table, String[] types)
           
 List<CachedRow> JdbcDatabaseSnapshot.CachingDatabaseMetaData.getUniqueConstraints(String catalogName, String schemaName, String tableName)
           
 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)
           
 

Constructors in liquibase.snapshot that throw DatabaseException
DatabaseSnapshot(DatabaseObject[] examples, Database database)
           
EmptyDatabaseSnapshot(Database database)
           
EmptyDatabaseSnapshot(Database database, SnapshotControl snapshotControl)
           
JdbcDatabaseSnapshot(DatabaseObject[] examples, Database database)
           
JdbcDatabaseSnapshot(DatabaseObject[] examples, Database database, SnapshotControl snapshotControl)
           
 

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 DataSnapshotGenerator.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<String,?>> UniqueConstraintSnapshotGenerator.listColumns(UniqueConstraint example, Database database)
           
protected  List<CachedRow> UniqueConstraintSnapshotGenerator.listConstraints(Table table, DatabaseSnapshot snapshot, Schema schema)
           
protected  Column ColumnSnapshotGenerator.readColumn(CachedRow columnMetadataResultSet, Relation table, Database database)
           
protected  Object ColumnSnapshotGenerator.readDefaultValue(CachedRow columnMetadataResultSet, Column columnInfo, Database database)
           
protected  Object H2ColumnSnapshotGenerator.readDefaultValue(CachedRow columnMetadataResultSet, Column columnInfo, Database database)
           
protected  Table TableSnapshotGenerator.readTable(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 DataSnapshotGenerator.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 SequenceSnapshotGenerator.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 © 2014 Liquibase.org. All Rights Reserved.