|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
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 |
---|
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)
|
|
|
Executor.queryForObject(SqlStatement sql,
Class<T> requiredType)
Read methods |
|
|
LoggingExecutor.queryForObject(SqlStatement sql,
Class<T> requiredType)
|
|
|
Executor.queryForObject(SqlStatement sql,
Class<T> requiredType,
List<SqlVisitor> sqlVisitors)
|
|
|
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)
|
|
|
JdbcExecutor.queryForObject(SqlStatement sql,
Class<T> requiredType)
|
|
|
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)
|
|
|
SnapshotGeneratorFactory.createSnapshot(T example,
Database database)
|
|
|
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
|
DatabaseSnapshot.include(T example)
Include the object described by the passed example object in this snapshot. |
|
|
SnapshotGeneratorChain.snapshot(T example,
DatabaseSnapshot snapshot)
|
|
|
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)
|
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |