Uses of Class
liquibase.exception.DatabaseException

Packages that use DatabaseException

Package	Description
liquibase	Liquibase top level namespace package.
liquibase.changelog
liquibase.changelog.filter
liquibase.command.core
liquibase.command.core.helpers
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.extension.testing.testsystem
liquibase.hub
liquibase.integration.cdi
liquibase.integration.commandline
liquibase.integration.jakarta.cdi
liquibase.integration.spring
liquibase.lockservice
liquibase.snapshot
liquibase.snapshot.jvm
liquibase.statement
liquibase.util

Uses of DatabaseException in liquibase

Methods in liquibase that throw DatabaseException

Modifier and Type	Method and Description
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) Deprecated. Use {link CommandScope(String) to generateChangelog instead of this method.
void	Liquibase.generateChangeLog(CatalogAndSchema catalogAndSchema, DiffToChangeLog changeLogWriter, PrintStream outputStream, Class<? extends DatabaseObject>... snapshotTypes) Deprecated. Use {link CommandScope(String) to generateChangelog instead of this method.
protected ChangeLogIterator	Liquibase.getStandardChangelogIterator(Contexts contexts, LabelExpression labelExpression, DatabaseChangeLog changeLog) Return a ChangeLogIterator constructed with standard filters
boolean	Liquibase.isSafeToRunUpdate() Returns true if it is "save" to migrate the database.
void	Liquibase.outputHeader(String message) Deprecated. use LoggingExecutorTextUtil#outputHeader(String, Database, String))

Uses of DatabaseException in liquibase.changelog

Methods in liquibase.changelog that throw DatabaseException

Modifier and Type	Method and Description
protected void	OfflineChangeLogHistoryService.appendChangeSet(ChangeSet changeSet, ChangeSet.ExecType execType)
void	MockChangeLogHistoryService.destroy()
void	OfflineChangeLogHistoryService.destroy()
void	StandardChangeLogHistoryService.destroy()
void	ChangeLogHistoryService.destroy()
String	AbstractChangeLogHistoryService.getLastDeploymentId() Return the last deployment ID from the changesets that have been run or null
RanChangeSet	MockChangeLogHistoryService.getRanChangeSet(ChangeSet changeSet)
RanChangeSet	StandardChangeLogHistoryService.getRanChangeSet(ChangeSet changeSet)
RanChangeSet	AbstractChangeLogHistoryService.getRanChangeSet(ChangeSet changeSet)
RanChangeSet	ChangeLogHistoryService.getRanChangeSet(ChangeSet changeSet)
List<RanChangeSet>	MockChangeLogHistoryService.getRanChangeSets()
List<RanChangeSet>	OfflineChangeLogHistoryService.getRanChangeSets()
List<RanChangeSet>	StandardChangeLogHistoryService.getRanChangeSets() Returns the ChangeSets that have been run against the current getDatabase().
List<RanChangeSet>	ChangeLogHistoryService.getRanChangeSets()
Date	MockChangeLogHistoryService.getRanDate(ChangeSet changeSet)
Date	AbstractChangeLogHistoryService.getRanDate(ChangeSet changeSet)
Date	ChangeLogHistoryService.getRanDate(ChangeSet changeSet) Returns the date the given changeSet was ran.
ChangeSet.RunStatus	MockChangeLogHistoryService.getRunStatus(ChangeSet changeSet)
ChangeSet.RunStatus	AbstractChangeLogHistoryService.getRunStatus(ChangeSet changeSet)
ChangeSet.RunStatus	ChangeLogHistoryService.getRunStatus(ChangeSet changeSet)
void	MockChangeLogHistoryService.init()
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	MockChangeLogHistoryService.removeFromHistory(ChangeSet changeSet)
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	MockChangeLogHistoryService.setExecType(ChangeSet changeSet, ChangeSet.ExecType execType)
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	MockChangeLogHistoryService.tag(String tagString)
void	OfflineChangeLogHistoryService.tag(String tagString)
void	StandardChangeLogHistoryService.tag(String tagString) Tags the database changelog with the given string.
void	ChangeLogHistoryService.tag(String tagString)
boolean	MockChangeLogHistoryService.tagExists(String tag)
boolean	OfflineChangeLogHistoryService.tagExists(String tag)
boolean	StandardChangeLogHistoryService.tagExists(String tag)
boolean	ChangeLogHistoryService.tagExists(String tag)
void	MockChangeLogHistoryService.upgradeChecksums(DatabaseChangeLog databaseChangeLog, Contexts contexts, LabelExpression labels)
void	StandardChangeLogHistoryService.upgradeChecksums(DatabaseChangeLog databaseChangeLog, Contexts contexts, LabelExpression labels)
void	AbstractChangeLogHistoryService.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

Uses of DatabaseException in liquibase.changelog.filter

Constructors in liquibase.changelog.filter that throw DatabaseException

Constructor and Description
ShouldRunChangeSetFilter(Database database)
ShouldRunChangeSetFilter(Database database, boolean ignoreClasspathPrefix)

Uses of DatabaseException in liquibase.command.core

Methods in liquibase.command.core that throw DatabaseException

Modifier and Type	Method and Description
DiffResult	DiffCommandStep.createDiffResult(CommandResultsBuilder resultsBuilder)
protected DatabaseSnapshot	DiffCommandStep.createReferenceSnapshot(CommandResultsBuilder resultsBuilder)
ChangeLogIterator	UpdateToTagCommandStep.getStandardChangelogIterator(CommandScope commandScope, Database database, Contexts contexts, LabelExpression labelExpression, DatabaseChangeLog changeLog)
ChangeLogIterator	UpdateCountCommandStep.getStandardChangelogIterator(CommandScope commandScope, Database database, Contexts contexts, LabelExpression labelExpression, DatabaseChangeLog databaseChangeLog)
ChangeLogIterator	AbstractUpdateCommandStep.getStandardChangelogIterator(CommandScope commandScope, Database database, Contexts contexts, LabelExpression labelExpression, DatabaseChangeLog changeLog)
protected ChangeLogIterator	StatusCommandStep.getStandardChangelogIterator(Contexts contexts, LabelExpression labelExpression, DatabaseChangeLog changeLog, Database database)
ChangeLogIterator	UpdateToTagCommandStep.getStatusChangelogIterator(CommandScope commandScope, Database database, Contexts contexts, LabelExpression labelExpression, DatabaseChangeLog changeLog)
ChangeLogIterator	UpdateCountCommandStep.getStatusChangelogIterator(CommandScope commandScope, Database database, Contexts contexts, LabelExpression labelExpression, DatabaseChangeLog databaseChangeLog)
ChangeLogIterator	AbstractUpdateCommandStep.getStatusChangelogIterator(CommandScope commandScope, Database database, Contexts contexts, LabelExpression labelExpression, DatabaseChangeLog changeLog)
protected DatabaseSnapshot	DiffCommandStep.getTargetSnapshot(CommandResultsBuilder resultsBuilder)

Uses of DatabaseException in liquibase.command.core.helpers

Methods in liquibase.command.core.helpers that throw DatabaseException

Modifier and Type	Method and Description
protected Database	AbstractDatabaseConnectionCommandStep.createDatabaseObject(String url, String username, String password, String defaultSchemaName, String defaultCatalogName, String driver, String driverPropertiesFile)

Uses of DatabaseException in liquibase.database

Methods in liquibase.database that throw DatabaseException

Modifier and Type	Method and Description
protected boolean	AbstractJdbcDatabase.canCreateChangeLogTable()
void	OfflineConnection.close()
void	DatabaseConnection.close()
void	Database.close()
void	AbstractJdbcDatabase.close()
void	MockDatabaseConnection.close()
void	OfflineConnection.commit()
void	DatabaseConnection.commit()
void	Database.commit()
void	AbstractJdbcDatabase.commit()
void	MockDatabaseConnection.commit()
PreparedStatement	PreparedStatementFactory.create(String sql) Create a PreparedStatement object, sql pre-compilation might take place, depending on driver support.
DatabaseConnection	ConnectionServiceFactory.create(String url, Driver driverObject, Properties driverProperties)
boolean	Database.disableForeignKeyChecks()
boolean	AbstractJdbcDatabase.disableForeignKeyChecks()
boolean	Database.doesTagExist(String tag) Deprecated. Use ChangeLogHistoryService.tagExists(String) instead
boolean	AbstractJdbcDatabase.doesTagExist(String tag)
void	Database.enableForeignKeyChecks()
void	AbstractJdbcDatabase.enableForeignKeyChecks()
Database	DatabaseFactory.findCorrectDatabaseImplementation(DatabaseConnection connection)
boolean	OfflineConnection.getAutoCommit()
boolean	DatabaseConnection.getAutoCommit()
boolean	MockDatabaseConnection.getAutoCommit()
String	OfflineConnection.getCatalog()
String	DatabaseConnection.getCatalog()
String	MockDatabaseConnection.getCatalog()
protected String	AbstractJdbcDatabase.getConnectionCatalogName()
int	OfflineConnection.getDatabaseMajorVersion()
int	DatabaseConnection.getDatabaseMajorVersion()
int	Database.getDatabaseMajorVersion()
int	AbstractJdbcDatabase.getDatabaseMajorVersion()
int	MockDatabaseConnection.getDatabaseMajorVersion()
int	OfflineConnection.getDatabaseMinorVersion()
int	DatabaseConnection.getDatabaseMinorVersion()
int	Database.getDatabaseMinorVersion()
int	AbstractJdbcDatabase.getDatabaseMinorVersion()
int	MockDatabaseConnection.getDatabaseMinorVersion()
String	OfflineConnection.getDatabaseProductName()
String	DatabaseConnection.getDatabaseProductName()
String	MockDatabaseConnection.getDatabaseProductName()
String	OfflineConnection.getDatabaseProductVersion()
String	DatabaseConnection.getDatabaseProductVersion()
String	Database.getDatabaseProductVersion()
String	AbstractJdbcDatabase.getDatabaseProductVersion()
String	MockDatabaseConnection.getDatabaseProductVersion()
RanChangeSet	Database.getRanChangeSet(ChangeSet changeSet)
RanChangeSet	AbstractJdbcDatabase.getRanChangeSet(ChangeSet changeSet)
List<RanChangeSet>	Database.getRanChangeSetList() Returns the ChangeSets that have been run against the current database.
List<RanChangeSet>	AbstractJdbcDatabase.getRanChangeSetList()
Date	Database.getRanDate(ChangeSet changeSet)
Date	AbstractJdbcDatabase.getRanDate(ChangeSet changeSet)
ChangeSet.RunStatus	Database.getRunStatus(ChangeSet changeSet) Returns the run status for the given ChangeSet
ChangeSet.RunStatus	AbstractJdbcDatabase.getRunStatus(ChangeSet changeSet)
String	Database.getViewDefinition(CatalogAndSchema schema, String name)
String	AbstractJdbcDatabase.getViewDefinition(CatalogAndSchema schema, String viewName)
boolean	Database.isAutoCommit()
boolean	AbstractJdbcDatabase.isAutoCommit()
boolean	OfflineConnection.isClosed()
boolean	DatabaseConnection.isClosed()
boolean	MockDatabaseConnection.isClosed()
boolean	Database.isCorrectDatabaseImplementation(DatabaseConnection conn) Is this AbstractDatabase subclass the correct one to use for the given connection.
boolean	Database.isSafeToRunUpdate()
boolean	AbstractJdbcDatabase.isSafeToRunUpdate() Default implementation, just look for "local" IPs.
void	Database.markChangeSetExecStatus(ChangeSet changeSet, ChangeSet.ExecType execType) After the changeset has been ran against the database this method will update the change log table with the information.
void	AbstractJdbcDatabase.markChangeSetExecStatus(ChangeSet changeSet, ChangeSet.ExecType execType)
String	OfflineConnection.nativeSQL(String sql)
String	DatabaseConnection.nativeSQL(String sql)
String	MockDatabaseConnection.nativeSQL(String sql)
void	OfflineConnection.open(String url, Driver driverObject, Properties driverProperties)
void	DatabaseConnection.open(String url, Driver driverObject, Properties driverProperties)
void	MockDatabaseConnection.open(String url, Driver driverObject, Properties driverProperties)
DatabaseConnection	DatabaseFactory.openConnection(String url, String username, String driver, String databaseClass, Properties driverProperties, ResourceAccessor resourceAccessor)
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 driver, String databaseClass, Properties driverProperties, 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	Database.removeRanStatus(ChangeSet changeSet)
void	AbstractJdbcDatabase.removeRanStatus(ChangeSet changeSet)
void	OfflineConnection.rollback()
void	DatabaseConnection.rollback()
void	Database.rollback()
void	AbstractJdbcDatabase.rollback()
void	MockDatabaseConnection.rollback()
void	OfflineConnection.setAutoCommit(boolean autoCommit)
void	DatabaseConnection.setAutoCommit(boolean autoCommit)
void	Database.setAutoCommit(boolean b)
void	AbstractJdbcDatabase.setAutoCommit(boolean b)
void	MockDatabaseConnection.setAutoCommit(boolean autoCommit)
void	Database.setDefaultCatalogName(String catalogName)
void	Database.setDefaultSchemaName(String schemaName)
boolean	Database.supportsBatchUpdates() Does the database support batched DML (INSERT/UPDATE/DELETE/MERGE/...) statements sent in a single call to the database?
boolean	AbstractJdbcDatabase.supportsBatchUpdates()
void	Database.tag(String tagString) Deprecated. Use ChangeLogHistoryService.tag(String) instead
void	AbstractJdbcDatabase.tag(String tagString)

Uses of DatabaseException in liquibase.database.core

Methods in liquibase.database.core that throw DatabaseException

Modifier and Type	Method and Description
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	HsqlDatabase.getConnectionCatalogName()
protected String	DerbyDatabase.getConnectionCatalogName()
protected String	OracleDatabase.getConnectionCatalogName()
int	CockroachDatabase.getDatabaseMajorVersion()
int	SybaseDatabase.getDatabaseMajorVersion()
int	OracleDatabase.getDatabaseMajorVersion()
int	CockroachDatabase.getDatabaseMinorVersion()
int	SybaseDatabase.getDatabaseMinorVersion()
int	OracleDatabase.getDatabaseMinorVersion()
int	MySQLDatabase.getDatabasePatchVersion()
RanChangeSet	MockDatabase.getRanChangeSet(ChangeSet changeSet)
List<RanChangeSet>	MockDatabase.getRanChangeSetList()
Date	MockDatabase.getRanDate(ChangeSet changeSet)
ChangeSet.RunStatus	MockDatabase.getRunStatus(ChangeSet changeSet)
String	SnowflakeDatabase.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)
String	H2Database.getViewDefinition(CatalogAndSchema schema, String name)
String	Ingres9Database.getViewDefinition(CatalogAndSchema schema, String viewName)
String	DerbyDatabase.getViewDefinition(CatalogAndSchema schema, String name)
String	AbstractDb2Database.getViewDefinition(CatalogAndSchema schema, String viewName)
String	InformixDatabase.getViewDefinition(CatalogAndSchema schema, String viewName)
static void	DatabaseUtils.initializeDatabase(String defaultCatalogName, String defaultSchemaName, Database database) Executes RawSqlStatements particular to each database engine to set the default schema for the given Database
boolean	SnowflakeDatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
boolean	MSSQLDatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
boolean	PostgresDatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
boolean	EnterpriseDBDatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
boolean	HsqlDatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
boolean	SQLiteDatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
boolean	DB2Database.isCorrectDatabaseImplementation(DatabaseConnection conn)
boolean	CockroachDatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
boolean	SybaseASADatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
boolean	SybaseDatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
boolean	UnsupportedDatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
boolean	H2Database.isCorrectDatabaseImplementation(DatabaseConnection conn)
boolean	Ingres9Database.isCorrectDatabaseImplementation(DatabaseConnection databaseConnection)
boolean	Db2zDatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
boolean	MySQLDatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
boolean	DerbyDatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
boolean	OracleDatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
boolean	FirebirdDatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
boolean	InformixDatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
boolean	MariaDBDatabase.isCorrectDatabaseImplementation(DatabaseConnection conn)
boolean	H2Database.isSafeToRunUpdate()
void	MockDatabase.markChangeSetExecStatus(ChangeSet changeSet, ChangeSet.ExecType execType)
void	MockDatabase.removeRanStatus(ChangeSet changeSet)
void	SnowflakeDatabase.rollback()
void	PostgresDatabase.rollback()
void	SybaseASADatabase.setAutoCommit(boolean b)
protected void	DerbyDatabase.shutdownDerby(String url, String driverName)

Uses of DatabaseException in liquibase.database.jvm

Methods in liquibase.database.jvm that throw DatabaseException

Modifier and Type	Method and Description
void	JdbcConnection.clearWarnings()
void	JdbcConnection.close()
void	DerbyConnection.commit()
void	JdbcConnection.commit()
void	HsqlConnection.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	SybaseASAConnection.nativeSQL(String sql)
String	JdbcConnection.nativeSQL(String sql)
void	JdbcConnection.open(String url, Driver driverObject, Properties driverProperties)
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	JdbcConnection.rollback()
void	HsqlConnection.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)
boolean	JdbcConnection.supportsBatchUpdates()

Uses of DatabaseException in liquibase.dbdoc

Methods in liquibase.dbdoc that throw DatabaseException

Modifier and Type	Method and Description
protected void	RecentChangesWriter.writeBody(Writer fileWriter, Object object, List<Change> ranChanges, List<Change> changesToRun)
protected void	HTMLWriter.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	PendingChangesWriter.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)
void	TableWriter.writeHTML(Object object, List<Change> ranChanges, List<Change> changesToRun, String changeLog, String schema)

Uses of DatabaseException in liquibase.diff

Methods in liquibase.diff that throw DatabaseException

Modifier and Type	Method and Description
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

Modifier and Type	Method and Description
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

Modifier and Type	Method and Description
protected void	DiffToChangeLog.addDependencies(DependencyUtil.DependencyGraph<String> graph, List<String> schemas, 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, Boolean overwriteOutputFile)
void	DiffToChangeLog.print(String changeLogFile, ChangeLogSerializer changeLogSerializer)
void	DiffToChangeLog.print(String changeLogFile, ChangeLogSerializer changeLogSerializer, Boolean overwriteOutputFile)
void	DiffToChangeLog.printNew(ChangeLogSerializer changeLogSerializer, Resource file) Prints changeLog that would bring the target database to be the same as the reference database

Uses of DatabaseException in liquibase.diff.output.report

Methods in liquibase.diff.output.report that throw DatabaseException

Modifier and Type	Method and Description
void	DiffToReport.print()

Uses of DatabaseException in liquibase.exception

Subclasses of DatabaseException in liquibase.exception

Modifier and Type	Class and Description
class	StatementNotSupportedOnDatabaseException

Uses of DatabaseException in liquibase.executor

Methods in liquibase.executor that throw DatabaseException

Modifier and Type	Method and Description
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) Executes a query that is expected to return a scalar (1 row, 1 column).
int	LoggingExecutor.queryForInt(SqlStatement sql, List<SqlVisitor> sqlVisitors)
int	Executor.queryForInt(SqlStatement sql, List<SqlVisitor> sqlVisitors) Applies a number of SqlVisitors to the sql query.
List<Map<String,?>>	LoggingExecutor.queryForList(SqlStatement sql)
List<Map<String,?>>	Executor.queryForList(SqlStatement sql) Executes a given SQL statement and returns a List of rows.
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) Applies a list of SqlVisitors to the SQL query, then executes the (possibly modified) SQL query and lastly, returns the list of rows.
long	LoggingExecutor.queryForLong(SqlStatement sql)
long	Executor.queryForLong(SqlStatement sql) Executes a query that is expected to return a scalar (1 row, 1 column).
long	LoggingExecutor.queryForLong(SqlStatement sql, List<SqlVisitor> sqlVisitors)
long	Executor.queryForLong(SqlStatement sql, List<SqlVisitor> sqlVisitors) Applies a number of SqlVisitors to the sql query.
<T> T	LoggingExecutor.queryForObject(SqlStatement sql, Class<T> requiredType)
<T> T	Executor.queryForObject(SqlStatement sql, Class<T> requiredType) Execute a query that is expected to return a scalar (1 row, 1 column).
<T> T	LoggingExecutor.queryForObject(SqlStatement sql, Class<T> requiredType, List<SqlVisitor> sqlVisitors)
<T> T	Executor.queryForObject(SqlStatement sql, Class<T> requiredType, List<SqlVisitor> sqlVisitors) Applies a number of SqlVisitors to the sql query.
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

Modifier and Type	Method and Description
void	JdbcExecutor.comment(String message)
Object	JdbcExecutor.execute(liquibase.executor.jvm.CallableStatementCallback action, List<SqlVisitor> sqlVisitors)
static void	ChangelogJdbcMdcListener.execute(Database database, ChangelogJdbcMdcListener.ExecuteJdbc jdbcQuery) Execute the given statement via the jdbc executor.
T	ChangelogJdbcMdcListener.QueryJdbc.execute(Executor executor)
void	ChangelogJdbcMdcListener.ExecuteJdbc.execute(Executor executor)
void	JdbcExecutor.execute(SqlStatement sql)
void	SnowflakeJdbcExecutor.execute(SqlStatement sql, List<SqlVisitor> sqlVisitors)
void	ExampleExecutor.execute(SqlStatement action, List<SqlVisitor> sqlVisitors) Execute the SQL from the SqlStatement parameter
void	JdbcExecutor.execute(SqlStatement sql, List<SqlVisitor> sqlVisitors)
Object	JdbcExecutor.execute(liquibase.executor.jvm.StatementCallback action, List<SqlVisitor> sqlVisitors)
static <T> T	ChangelogJdbcMdcListener.query(Database database, ChangelogJdbcMdcListener.QueryJdbc<T> jdbcQuery) Execute the given statement via the jdbc executor.
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.extension.testing.testsystem

Methods in liquibase.extension.testing.testsystem that throw DatabaseException

Modifier and Type	Method and Description
void	DatabaseTestSystem.execute(Change change)
void	DatabaseTestSystem.execute(SqlStatement sqlStatement)
void	DatabaseTestSystem.executeInverses(Change change)
Database	DatabaseTestSystem.getDatabaseFromFactory()

Uses of DatabaseException in liquibase.hub

Methods in liquibase.hub that throw DatabaseException

Modifier and Type	Method and Description
Operation	HubUpdater.preUpdateHub(String operationType, String operationCommand, Connection connection, String changeLogFile, Contexts contexts, LabelExpression labelExpression, ChangeLogIterator changeLogIterator) This method performs a syncHub and returns a new Operation instance If there is an error or the Hub is not available it returns null

Uses of DatabaseException in liquibase.integration.cdi

Methods in liquibase.integration.cdi that throw DatabaseException

Modifier and Type	Method and Description
protected Database	CDILiquibase.createDatabase(Connection c) Subclasses may override this method add change some database settings such as default schema before returning the database object.

Uses of DatabaseException in liquibase.integration.commandline

Methods in liquibase.integration.commandline that throw DatabaseException

Modifier and Type	Method and Description
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) Deprecated.

Uses of DatabaseException in liquibase.integration.jakarta.cdi

Methods in liquibase.integration.jakarta.cdi that throw DatabaseException

Modifier and Type	Method and Description
protected Database	CDILiquibase.createDatabase(Connection c) Subclasses may override this method add change some database settings such as default schema before returning the database object.

Uses of DatabaseException in liquibase.integration.spring

Methods in liquibase.integration.spring that throw DatabaseException

Modifier and Type	Method and Description
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

Modifier and Type	Method and Description
void	OfflineLockService.destroy()
void	LockService.destroy()
void	MockLockService.destroy()
void	StandardLockService.destroy()
void	OfflineLockService.forceReleaseLock()
void	LockService.forceReleaseLock() Releases whatever locks are on the database change log table
void	MockLockService.forceReleaseLock()
void	StandardLockService.forceReleaseLock()
protected boolean	StandardLockService.hasDatabaseChangeLogLockTable()
void	OfflineLockService.init()
void	LockService.init()
void	MockLockService.init()
void	StandardLockService.init()

Uses of DatabaseException in liquibase.snapshot

Methods in liquibase.snapshot that throw DatabaseException

Modifier and Type	Method and Description
abstract List<CachedRow>	ResultSetCache.ResultSetExtractor.bulkFetch()
List<CachedRow>	ResultSetCache.SingleResultSetExtractor.bulkFetch()
abstract List<CachedRow>	ResultSetCache.SingleResultSetExtractor.bulkFetchQuery()
DatabaseSnapshot	SnapshotGeneratorFactory.createSnapshot(CatalogAndSchema[] examples, Database database, SnapshotControl snapshotControl) Creates a database snapshot for a given array of catalog/schema combinations.
DatabaseSnapshot	SnapshotGeneratorFactory.createSnapshot(CatalogAndSchema example, Database database, SnapshotControl snapshotControl)
DatabaseSnapshot	SnapshotGeneratorFactory.createSnapshot(DatabaseObject[] examples, Database database, SnapshotControl snapshotControl) Creates a database snapshot for a given array of DatabaseObjects
<T extends DatabaseObject> T	SnapshotGeneratorFactory.createSnapshot(T example, Database database) Creates a DatabaseSnapshot for a single DatabaseObject.
<T extends DatabaseObject> T	SnapshotGeneratorFactory.createSnapshot(T example, Database database, SnapshotControl snapshotControl) Creates a DatabaseSnapshot for a single DatabaseObject.
List<CachedRow>	ResultSetCacheSnowflake.SingleResultSetExtractor.executeAndExtract(String sql, Database database)
protected List<CachedRow>	ResultSetCache.ResultSetExtractor.executeAndExtract(String sql, Database database)
List<CachedRow>	ResultSetCacheSnowflake.SingleResultSetExtractor.executeAndExtract(String sql, Database database, boolean informixTrimHint)
protected List<CachedRow>	ResultSetCache.ResultSetExtractor.executeAndExtract(String sql, Database database, boolean informixTrimHint)
abstract List<CachedRow>	ResultSetCache.ResultSetExtractor.fastFetch()
List<CachedRow>	ResultSetCache.SingleResultSetExtractor.fastFetch()
abstract List<CachedRow>	ResultSetCache.SingleResultSetExtractor.fastFetchQuery()
List<CachedRow>	ResultSetCache.get(ResultSetCache.ResultSetExtractor resultSetExtractor)
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.getNotNullConst(String catalogName, String schemaName, String tableName) Return the NotNullConstraints for the given catalog, schema, table, and column.
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 viewName)
boolean	SnapshotGeneratorFactory.has(DatabaseObject example, Database database) Checks if a specific object is present in a 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) Commands the SnapshotGenerator to create a snapshot (a representation of a database object in Java object form) of a specific database object.

Constructors in liquibase.snapshot that throw DatabaseException

Constructor and Description
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

Modifier and Type	Method and Description
protected void	CatalogSnapshotGenerator.addTo(DatabaseObject foundObject, DatabaseSnapshot snapshot)
protected void	ColumnSnapshotGenerator.addTo(DatabaseObject foundObject, DatabaseSnapshot snapshot)
protected void	UniqueConstraintSnapshotGenerator.addTo(DatabaseObject foundObject, DatabaseSnapshot snapshot)
protected void	ViewSnapshotGenerator.addTo(DatabaseObject foundObject, DatabaseSnapshot snapshot)
protected void	IndexSnapshotGenerator.addTo(DatabaseObject foundObject, DatabaseSnapshot snapshot)
protected void	SchemaSnapshotGenerator.addTo(DatabaseObject foundObject, DatabaseSnapshot snapshot)
protected void	PrimaryKeySnapshotGenerator.addTo(DatabaseObject foundObject, DatabaseSnapshot snapshot)
protected abstract void	JdbcSnapshotGenerator.addTo(DatabaseObject foundObject, DatabaseSnapshot snapshot)
protected void	DataSnapshotGenerator.addTo(DatabaseObject foundObject, DatabaseSnapshot snapshot)
protected void	ForeignKeySnapshotGenerator.addTo(DatabaseObject foundObject, DatabaseSnapshot snapshot)
protected void	TableSnapshotGenerator.addTo(DatabaseObject foundObject, DatabaseSnapshot snapshot)
protected void	SequenceSnapshotGenerator.addTo(DatabaseObject foundObject, DatabaseSnapshot snapshot)
List<CachedRow>	SnowflakeResultSetConstraintsExtractor.bulkFetchQuery()
protected ForeignKeyConstraintType	ForeignKeySnapshotGenerator.convertToForeignKeyConstraintType(Integer jdbcType, Database database)
List<CachedRow>	SnowflakeResultSetConstraintsExtractor.fastFetchQuery()
protected String[]	JdbcSnapshotGenerator.getDatabaseCatalogNames(Database database) Fetches an array of Strings with the catalog names in the database.
protected String[]	SchemaSnapshotGeneratorSnowflake.getDatabaseSchemaNames(Database database)
protected String[]	SchemaSnapshotGenerator.getDatabaseSchemaNames(Database database) Fetches an array of Strings with the schema names in the database.
protected List<Map<String,?>>	UniqueConstraintSnapshotGeneratorSnowflake.listColumns(UniqueConstraint example, Database database, DatabaseSnapshot snapshot)
protected List<Map<String,?>>	UniqueConstraintSnapshotGenerator.listColumns(UniqueConstraint example, Database database, DatabaseSnapshot snapshot)
protected List<CachedRow>	UniqueConstraintSnapshotGeneratorSnowflake.listConstraints(Table table, DatabaseSnapshot snapshot, Schema schema)
protected List<CachedRow>	UniqueConstraintSnapshotGenerator.listConstraints(Table table, DatabaseSnapshot snapshot, Schema schema)
protected Column	ColumnSnapshotGenerator.readColumn(CachedRow columnMetadataResultSet, Relation table, Database database)
protected DataType	ColumnSnapshotGenerator.readDataType(CachedRow columnMetadataResultSet, Column column, Database database) Processes metadata of a column, e.g.
protected DataType	ColumnSnapshotGeneratorInformix.readDataType(CachedRow columnMetadataResultSet, Column column, 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	UniqueConstraintSnapshotGenerator.snapshotObject(DatabaseObject example, DatabaseSnapshot snapshot)
protected DatabaseObject	ViewSnapshotGenerator.snapshotObject(DatabaseObject example, DatabaseSnapshot snapshot)
protected DatabaseObject	IndexSnapshotGenerator.snapshotObject(DatabaseObject example, DatabaseSnapshot snapshot)
protected DatabaseObject	SchemaSnapshotGenerator.snapshotObject(DatabaseObject example, DatabaseSnapshot snapshot)
protected DatabaseObject	PrimaryKeySnapshotGenerator.snapshotObject(DatabaseObject example, DatabaseSnapshot snapshot)
protected abstract DatabaseObject	JdbcSnapshotGenerator.snapshotObject(DatabaseObject example, DatabaseSnapshot snapshot)
protected DatabaseObject	DataSnapshotGenerator.snapshotObject(DatabaseObject example, DatabaseSnapshot snapshot)
protected DatabaseObject	ForeignKeySnapshotGenerator.snapshotObject(DatabaseObject example, DatabaseSnapshot snapshot)
protected DatabaseObject	TableSnapshotGenerator.snapshotObject(DatabaseObject example, DatabaseSnapshot snapshot)
protected DatabaseObject	SequenceSnapshotGenerator.snapshotObject(DatabaseObject example, DatabaseSnapshot snapshot)

Uses of DatabaseException in liquibase.statement

Methods in liquibase.statement that throw DatabaseException

Modifier and Type	Method and Description
protected void	ExecutablePreparedStatementBase.applyColumnParameter(PreparedStatement stmt, int i, ColumnConfig col) Sets a single bind variable for a statement to its designated value
protected void	BatchDmlExecutablePreparedStatement.attachParams(List<? extends ColumnConfig> ignored, PreparedStatement stmt)
protected void	ExecutablePreparedStatementBase.attachParams(List<? extends ColumnConfig> cols, PreparedStatement stmt) Sets the list of bind variables for the execution of a DML statement
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

Modifier and Type	Method and Description
static void	LoggingExecutorTextUtil.outputHeader(String message, Database database, String changeLogFile)
static Object	JdbcUtil.requiredSingleResult(Collection results) Return a single result object from the given Collection.