Uses of Class
liquibase.exception.DatabaseException

Packages that use DatabaseException
liquibase   
liquibase.changelog   
liquibase.changelog.filter   
liquibase.command   
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.sdk.database   
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 in the default schema.
 void Liquibase.dropAll(CatalogAndSchema... schemas)
          Drops all database objects in the passed schema(s).
 void Liquibase.generateChangeLog(CatalogAndSchema catalogAndSchema, DiffToChangeLog changeLogWriter, PrintStream outputStream, ChangeLogSerializer changeLogSerializer, Class<? extends DatabaseObject>... snapshotTypes)
           
 void Liquibase.generateChangeLog(CatalogAndSchema catalogAndSchema, DiffToChangeLog changeLogWriter, PrintStream outputStream, Class<? extends DatabaseObject>... snapshotTypes)
           
protected  ChangeLogIterator Liquibase.getStandardChangelogIterator(Contexts contexts, LabelExpression labelExpression, 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 OfflineChangeLogHistoryService.destroy()
           
 void StandardChangeLogHistoryService.destroy()
           
 void ChangeLogHistoryService.destroy()
           
 RanChangeSet StandardChangeLogHistoryService.getRanChangeSet(ChangeSet changeSet)
           
 RanChangeSet ChangeLogHistoryService.getRanChangeSet(ChangeSet changeSet)
           
 RanChangeSet AbstractChangeLogHistoryService.getRanChangeSet(ChangeSet changeSet)
           
 List<RanChangeSet> OfflineChangeLogHistoryService.getRanChangeSets()
           
 List<RanChangeSet> StandardChangeLogHistoryService.getRanChangeSets()
          Returns the ChangeSets that have been run against the current getDatabase().
 List<RanChangeSet> ChangeLogHistoryService.getRanChangeSets()
           
 Date ChangeLogHistoryService.getRanDate(ChangeSet changeSet)
          Returns the date the given changeSet was ran.
 Date AbstractChangeLogHistoryService.getRanDate(ChangeSet changeSet)
           
 ChangeSet.RunStatus ChangeLogHistoryService.getRunStatus(ChangeSet changeSet)
           
 ChangeSet.RunStatus AbstractChangeLogHistoryService.getRunStatus(ChangeSet changeSet)
           
 boolean StandardChangeLogHistoryService.hasDatabaseChangeLogTable()
           
 void OfflineChangeLogHistoryService.init()
           
 void StandardChangeLogHistoryService.init()
           
 void ChangeLogHistoryService.init()
          Ensures the change log history container is correctly initialized for use.
 List<Map<String,?>> StandardChangeLogHistoryService.queryDatabaseChangeLogTable(Database database)
           
 void OfflineChangeLogHistoryService.removeFromHistory(ChangeSet changeSet)
           
 void StandardChangeLogHistoryService.removeFromHistory(ChangeSet changeSet)
           
 void ChangeLogHistoryService.removeFromHistory(ChangeSet changeSet)
           
protected  void OfflineChangeLogHistoryService.replaceChangeSet(ChangeSet changeSet, liquibase.changelog.OfflineChangeLogHistoryService.ReplaceChangeSetLogic replaceLogic)
           
protected  void OfflineChangeLogHistoryService.replaceChecksum(ChangeSet changeSet)
           
protected  void StandardChangeLogHistoryService.replaceChecksum(ChangeSet changeSet)
           
protected abstract  void AbstractChangeLogHistoryService.replaceChecksum(ChangeSet changeSet)
           
 void OfflineChangeLogHistoryService.setExecType(ChangeSet changeSet, ChangeSet.ExecType execType)
           
 void StandardChangeLogHistoryService.setExecType(ChangeSet changeSet, ChangeSet.ExecType execType)
           
 void ChangeLogHistoryService.setExecType(ChangeSet changeSet, ChangeSet.ExecType execType)
           
 void OfflineChangeLogHistoryService.tag(String tagString)
           
 void StandardChangeLogHistoryService.tag(String tagString)
          Tags the database changelog with the given string.
 void ChangeLogHistoryService.tag(String tagString)
           
 boolean OfflineChangeLogHistoryService.tagExists(String tag)
           
 boolean StandardChangeLogHistoryService.tagExists(String tag)
           
 boolean ChangeLogHistoryService.tagExists(String tag)
           
 void StandardChangeLogHistoryService.upgradeChecksums(DatabaseChangeLog databaseChangeLog, Contexts contexts, LabelExpression labels)
           
 void ChangeLogHistoryService.upgradeChecksums(DatabaseChangeLog databaseChangeLog, Contexts contexts, LabelExpression labels)
          Upgrades any existing checksums with an out of date version
 void AbstractChangeLogHistoryService.upgradeChecksums(DatabaseChangeLog databaseChangeLog, Contexts contexts, LabelExpression labels)
           
 

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.command
 

Methods in liquibase.command that throw DatabaseException
protected  DiffResult DiffCommand.createDiffResult()
           
protected  DatabaseSnapshot DiffCommand.createReferenceSnapshot()
           
protected  DatabaseSnapshot DiffCommand.createTargetSnapshot()
           
protected  DatabaseSnapshot GenerateChangeLogCommand.createTargetSnapshot()
           
 

Uses of DatabaseException in liquibase.database
 

Methods in liquibase.database that throw DatabaseException
protected  boolean AbstractJdbcDatabase.canCreateChangeLogTable()
           
 void AbstractJdbcDatabase.close()
           
 void OfflineConnection.close()
           
 void DatabaseConnection.close()
           
 void Database.close()
           
 void AbstractJdbcDatabase.commit()
           
 void OfflineConnection.commit()
           
 void DatabaseConnection.commit()
           
 void Database.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 OfflineConnection.getAutoCommit()
           
 boolean DatabaseConnection.getAutoCommit()
           
 String OfflineConnection.getCatalog()
           
 String DatabaseConnection.getCatalog()
           
protected  String AbstractJdbcDatabase.getConnectionCatalogName()
           
 int AbstractJdbcDatabase.getDatabaseMajorVersion()
           
 int OfflineConnection.getDatabaseMajorVersion()
           
 int DatabaseConnection.getDatabaseMajorVersion()
           
 int Database.getDatabaseMajorVersion()
           
 int AbstractJdbcDatabase.getDatabaseMinorVersion()
           
 int OfflineConnection.getDatabaseMinorVersion()
           
 int DatabaseConnection.getDatabaseMinorVersion()
           
 int Database.getDatabaseMinorVersion()
           
 String OfflineConnection.getDatabaseProductName()
           
 String DatabaseConnection.getDatabaseProductName()
           
 String AbstractJdbcDatabase.getDatabaseProductVersion()
           
 String OfflineConnection.getDatabaseProductVersion()
           
 String DatabaseConnection.getDatabaseProductVersion()
           
 String Database.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 OfflineConnection.isClosed()
           
 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 OfflineConnection.nativeSQL(String sql)
           
 String DatabaseConnection.nativeSQL(String sql)
           
 DatabaseConnection DatabaseFactory.openConnection(String url, String username, String password, String propertyProvider, ResourceAccessor resourceAccessor)
           
 DatabaseConnection DatabaseFactory.openConnection(String url, String username, String password, String driver, String databaseClass, String driverPropertiesFile, String propertyProviderClass, ResourceAccessor resourceAccessor)
           
 Database DatabaseFactory.openDatabase(String url, String username, String password, String propertyProviderClass, ResourceAccessor resourceAccessor)
           
 Database DatabaseFactory.openDatabase(String url, String username, String password, String driver, String databaseClass, String driverPropertiesFile, String propertyProviderClass, ResourceAccessor resourceAccessor)
           
 void AbstractJdbcDatabase.removeRanStatus(ChangeSet changeSet)
           
 void Database.removeRanStatus(ChangeSet changeSet)
           
 void AbstractJdbcDatabase.rollback()
           
 void OfflineConnection.rollback()
           
 void DatabaseConnection.rollback()
           
 void Database.rollback()
           
 void AbstractJdbcDatabase.setAutoCommit(boolean b)
           
 void OfflineConnection.setAutoCommit(boolean autoCommit)
           
 void DatabaseConnection.setAutoCommit(boolean autoCommit)
           
 void Database.setAutoCommit(boolean b)
           
 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 OracleDatabase.getConnectionCatalogName()
           
protected  String HsqlDatabase.getConnectionCatalogName()
           
protected  String DerbyDatabase.getConnectionCatalogName()
           
 int OracleDatabase.getDatabaseMajorVersion()
           
 int SybaseDatabase.getDatabaseMajorVersion()
           
 int SybaseDatabase.getDatabaseMinorVersion()
           
 int MySQLDatabase.getDatabasePatchVersion()
           
 String DB2Database.getViewDefinition(CatalogAndSchema schema, String viewName)
           
 String SybaseDatabase.getViewDefinition(CatalogAndSchema schema, String viewName)
           
 String H2Database.getViewDefinition(CatalogAndSchema schema, String name)
           
 String MSSQLDatabase.getViewDefinition(CatalogAndSchema schema, String viewName)
           
 String InformixDatabase.getViewDefinition(CatalogAndSchema schema, String viewName)
           
 String DerbyDatabase.getViewDefinition(CatalogAndSchema schema, String name)
           
 String SQLiteDatabase.getViewDefinition(CatalogAndSchema schema, String viewName)
           
 String SybaseASADatabase.getViewDefinition(CatalogAndSchema schema, String viewName)
           
 boolean DB2Database.isCorrectDatabaseImplementation(DatabaseConnection conn)
           
 boolean MariaDBDatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
           
 boolean OracleDatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
           
 boolean SybaseDatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
           
 boolean HsqlDatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
           
 boolean H2Database.isCorrectDatabaseImplementation(DatabaseConnection conn)
           
 boolean MSSQLDatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
           
 boolean UnsupportedDatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
           
 boolean InformixDatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
           
 boolean DerbyDatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
           
 boolean MySQLDatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
           
 boolean PostgresDatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
           
 boolean SQLiteDatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
           
 boolean SybaseASADatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
           
 boolean FirebirdDatabase.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 SybaseConnection.commit()
           
 void HsqlConnection.commit()
           
 void JdbcConnection.commit()
           
 void DerbyConnection.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 SybaseConnection.rollback()
           
 void HsqlConnection.rollback()
           
 void JdbcConnection.rollback()
           
 void DerbyConnection.rollback()
           
 void SybaseConnection.rollback(Savepoint savepoint)
           
 void JdbcConnection.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(Writer fileWriter, Object object, List<Change> ranChanges, List<Change> changesToRun)
           
protected  void PendingChangesWriter.writeBody(Writer fileWriter, Object object, List<Change> ranChanges, List<Change> changesToRun)
           
protected  void RecentChangesWriter.writeBody(Writer fileWriter, Object object, List<Change> ranChanges, List<Change> changesToRun)
           
protected  void PendingSQLWriter.writeBody(Writer fileWriter, Object object, List<Change> ranChanges, List<Change> changesToRun)
           
protected  void HTMLWriter.writeChanges(String title, Writer 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 DiffGeneratorFactory.compare(DatabaseSnapshot referenceSnapshot, DatabaseSnapshot comparisonSnapshot, CompareControl compareControl)
           
 DiffResult DiffGenerator.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.addDependencies(DependencyUtil.DependencyGraph<String> graph, List<String> schemas, Collection<DatabaseObject> missingObjects, Database database)
          Adds dependencies to the graph as schema.object_name.
 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 LoggingExecutor.comment(String message)
           
 void Executor.comment(String message)
          Adds a comment to the database.
 void Executor.execute(Change change)
          Write methods
 void AbstractExecutor.execute(Change change)
           
 void Executor.execute(Change change, List<SqlVisitor> sqlVisitors)
           
 void AbstractExecutor.execute(Change change, List<SqlVisitor> sqlVisitors)
           
 void LoggingExecutor.execute(SqlStatement sql)
           
 void Executor.execute(SqlStatement sql)
           
 void LoggingExecutor.execute(SqlStatement sql, List<SqlVisitor> sqlVisitors)
           
 void Executor.execute(SqlStatement sql, List<SqlVisitor> sqlVisitors)
           
 int LoggingExecutor.queryForInt(SqlStatement sql)
           
 int Executor.queryForInt(SqlStatement sql)
           
 int LoggingExecutor.queryForInt(SqlStatement sql, List<SqlVisitor> sqlVisitors)
           
 int Executor.queryForInt(SqlStatement sql, List<SqlVisitor> sqlVisitors)
           
 List<Map<String,?>> LoggingExecutor.queryForList(SqlStatement sql)
           
 List<Map<String,?>> Executor.queryForList(SqlStatement sql)
           
 List LoggingExecutor.queryForList(SqlStatement sql, Class elementType)
           
 List Executor.queryForList(SqlStatement sql, Class elementType)
           
 List LoggingExecutor.queryForList(SqlStatement sql, Class elementType, List<SqlVisitor> sqlVisitors)
           
 List Executor.queryForList(SqlStatement sql, Class elementType, List<SqlVisitor> sqlVisitors)
           
 List<Map<String,?>> LoggingExecutor.queryForList(SqlStatement sql, List<SqlVisitor> sqlVisitors)
           
 List<Map<String,?>> Executor.queryForList(SqlStatement sql, List<SqlVisitor> sqlVisitors)
           
 long LoggingExecutor.queryForLong(SqlStatement sql)
           
 long Executor.queryForLong(SqlStatement sql)
           
 long LoggingExecutor.queryForLong(SqlStatement sql, List<SqlVisitor> sqlVisitors)
           
 long Executor.queryForLong(SqlStatement sql, List<SqlVisitor> sqlVisitors)
           
<T> T
LoggingExecutor.queryForObject(SqlStatement sql, Class<T> requiredType)
           
<T> T
Executor.queryForObject(SqlStatement sql, Class<T> requiredType)
          Read methods
<T> T
LoggingExecutor.queryForObject(SqlStatement sql, Class<T> requiredType, List<SqlVisitor> sqlVisitors)
           
<T> T
Executor.queryForObject(SqlStatement sql, Class<T> requiredType, List<SqlVisitor> sqlVisitors)
           
 int LoggingExecutor.update(SqlStatement sql)
           
 int Executor.update(SqlStatement sql)
           
 int LoggingExecutor.update(SqlStatement sql, List<SqlVisitor> sqlVisitors)
           
 int Executor.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 propertyProviderClass, String liquibaseCatalogName, String liquibaseSchemaName, String databaseChangeLogTableName, String databaseChangeLogLockTableName)
          Deprecated. Use ResourceAccessor version
static Database CommandLineUtils.createDatabaseObject(ResourceAccessor resourceAccessor, String url, String username, String password, String driver, String defaultCatalogName, String defaultSchemaName, boolean outputDefaultCatalog, boolean outputDefaultSchema, String databaseClass, String driverPropertiesFile, String propertyProviderClass, String liquibaseCatalogName, String liquibaseSchemaName, String databaseChangeLogTableName, String databaseChangeLogLockTableName)
           
static void CommandLineUtils.doGenerateChangeLog(String changeLogFile, Database originalDatabase, CatalogAndSchema[] schemas, String snapshotTypes, String author, String context, String dataDir, DiffOutputControl diffOutputControl)
           
static void CommandLineUtils.doGenerateChangeLog(String changeLogFile, Database originalDatabase, String catalogName, String schemaName, String snapshotTypes, String author, String context, String dataDir, DiffOutputControl diffOutputControl)
           
static void CommandLineUtils.initializeDatabase(String username, String defaultCatalogName, String defaultSchemaName, Database database)
          Executes RawSqlStatements particular to each database engine to set the default schema for the given Database
 

Uses of DatabaseException in liquibase.integration.spring
 

Methods in liquibase.integration.spring that throw DatabaseException
protected  Database SpringLiquibase.createDatabase(Connection c, ResourceAccessor resourceAccessor)
          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 OfflineLockService.destroy()
           
 void StandardLockService.destroy()
           
 void LockService.destroy()
           
 void OfflineLockService.forceReleaseLock()
           
 void StandardLockService.forceReleaseLock()
           
 void LockService.forceReleaseLock()
          Releases whatever locks are on the database change log table
 boolean StandardLockService.hasDatabaseChangeLogLockTable()
           
 void OfflineLockService.init()
           
 void StandardLockService.init()
           
 void LockService.init()
           
 boolean StandardLockService.isDatabaseChangeLogLockTableInitialized(boolean tableJustCreated)
           
 

Uses of DatabaseException in liquibase.sdk.database
 

Methods in liquibase.sdk.database that throw DatabaseException
 void MockDatabase.close()
           
 String MockDatabase.convertRequestedSchemaToCatalog(String requestedSchema)
           
 String MockDatabase.convertRequestedSchemaToSchema(String requestedSchema)
           
 boolean MockDatabase.disableForeignKeyChecks()
           
 boolean MockDatabase.doesTagExist(String tag)
           
 void MockDatabase.dropDatabaseObjects(CatalogAndSchema schema)
           
 void MockDatabase.enableForeignKeyChecks()
           
 String MockDatabase.getConnectionURL()
           
 String MockDatabase.getConnectionUsername()
           
 int MockDatabase.getDatabaseMajorVersion()
           
 int MockDatabase.getDatabaseMinorVersion()
           
 String MockDatabase.getDatabaseProductName(DatabaseConnection conn)
           
 String MockDatabase.getDatabaseProductVersion()
           
 String MockDatabase.getDriverName()
           
 RanChangeSet MockDatabase.getRanChangeSet(ChangeSet changeSet)
           
 List<RanChangeSet> MockDatabase.getRanChangeSetList()
           
 Date MockDatabase.getRanDate(ChangeSet changeSet)
           
 ChangeSet.RunStatus MockDatabase.getRunStatus(ChangeSet changeSet)
           
 SqlStatement MockDatabase.getSelectChangeLogLockSQL()
           
 String MockDatabase.getViewDefinition(CatalogAndSchema schema, String name)
           
 boolean MockDatabase.isAutoCommit()
           
 boolean MockDatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
           
 boolean MockDatabase.isSafeToRunUpdate()
           
 void MockDatabase.markChangeSetExecStatus(ChangeSet changeSet, ChangeSet.ExecType execType)
           
 void MockDatabase.removeRanStatus(ChangeSet changeSet)
           
 void MockDatabase.setAutoCommit(boolean b)
           
 void MockDatabase.setDefaultCatalogName(String catalogName)
           
 void MockDatabase.setDefaultSchemaName(String schemaName)
           
 void MockDatabase.tag(String tagString)
           
 void MockDatabase.updateChecksum(ChangeSet changeSet)
           
 

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)
           
 List<CachedRow> JdbcDatabaseSnapshot.CachingDatabaseMetaData.getUniqueConstraints(String catalogName, String schemaName, String tableName)
           
 List<CachedRow> JdbcDatabaseSnapshot.CachingDatabaseMetaData.getViews(String catalogName, String schemaName, String view)
           
 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.
protected  void DatabaseSnapshot.init(DatabaseObject[] examples)
           
<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)
           
RestoredDatabaseSnapshot(Database database)
           
 

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 PrimaryKeySnapshotGenerator.addTo(DatabaseObject foundObject, DatabaseSnapshot snapshot)
           
protected  void SchemaSnapshotGenerator.addTo(DatabaseObject foundObject, DatabaseSnapshot snapshot)
           
protected  void DataSnapshotGenerator.addTo(DatabaseObject foundObject, DatabaseSnapshot snapshot)
           
protected  void TableSnapshotGenerator.addTo(DatabaseObject foundObject, DatabaseSnapshot snapshot)
           
protected  void ViewSnapshotGenerator.addTo(DatabaseObject foundObject, DatabaseSnapshot snapshot)
           
protected  void SequenceSnapshotGenerator.addTo(DatabaseObject foundObject, DatabaseSnapshot snapshot)
           
protected  void ForeignKeySnapshotGenerator.addTo(DatabaseObject foundObject, DatabaseSnapshot snapshot)
           
protected  void IndexSnapshotGenerator.addTo(DatabaseObject foundObject, DatabaseSnapshot snapshot)
           
protected  void UniqueConstraintSnapshotGenerator.addTo(DatabaseObject foundObject, DatabaseSnapshot snapshot)
           
protected abstract  void JdbcSnapshotGenerator.addTo(DatabaseObject foundObject, DatabaseSnapshot snapshot)
           
protected  ForeignKeyConstraintType ForeignKeySnapshotGenerator.convertToForeignKeyConstraintType(Integer jdbcType, Database database)
           
protected  String[] CatalogSnapshotGenerator.getDatabaseCatalogNames(Database database)
           
protected  String[] SchemaSnapshotGenerator.getDatabaseSchemaNames(Database database)
           
protected  List<Map<String,?>> UniqueConstraintSnapshotGenerator.listColumns(UniqueConstraint example, Database database, DatabaseSnapshot snapshot)
           
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 PrimaryKeySnapshotGenerator.snapshotObject(DatabaseObject example, DatabaseSnapshot snapshot)
           
protected  DatabaseObject SchemaSnapshotGenerator.snapshotObject(DatabaseObject example, DatabaseSnapshot snapshot)
           
protected  DatabaseObject DataSnapshotGenerator.snapshotObject(DatabaseObject example, DatabaseSnapshot snapshot)
           
protected  DatabaseObject TableSnapshotGenerator.snapshotObject(DatabaseObject example, DatabaseSnapshot snapshot)
           
protected  DatabaseObject ViewSnapshotGenerator.snapshotObject(DatabaseObject example, DatabaseSnapshot snapshot)
           
protected  DatabaseObject SequenceSnapshotGenerator.snapshotObject(DatabaseObject example, DatabaseSnapshot snapshot)
           
protected  DatabaseObject ForeignKeySnapshotGenerator.snapshotObject(DatabaseObject example, DatabaseSnapshot snapshot)
           
protected  DatabaseObject IndexSnapshotGenerator.snapshotObject(DatabaseObject example, DatabaseSnapshot snapshot)
           
protected  DatabaseObject UniqueConstraintSnapshotGenerator.snapshotObject(DatabaseObject example, DatabaseSnapshot snapshot)
           
protected abstract  DatabaseObject JdbcSnapshotGenerator.snapshotObject(DatabaseObject example, DatabaseSnapshot snapshot)
           
 

Uses of DatabaseException in liquibase.statement
 

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

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 UIFacade.promptForNonLocalDatabase(Database database)
           
 boolean SwingUIFacade.promptForNonLocalDatabase(Database database)
          Displays swing-based dialog about running against a non-localhost database.
 



Copyright © 2016 Liquibase.org. All rights reserved.