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.integration.cdi
liquibase.integration.commandline
liquibase.integration.jakarta.cdi
liquibase.integration.spring
liquibase.lockservice
liquibase.report
liquibase.snapshot
liquibase.snapshot.jvm
liquibase.statement
liquibase.util

Uses of DatabaseException in liquibase

Methods in liquibase that throw DatabaseException

Modifier and Type	Method	Description
final void	Liquibase.dropAll()	Drops all database objects in the default schema.
final void	Liquibase.dropAll(Boolean dropDbclhistory)	Drops all database objects in the default schema.
final void	Liquibase.dropAll(Boolean dropDbclhistory, CatalogAndSchema... schemas)	Drops all database objects in the passed schema(s).
final void	Liquibase.dropAll(CatalogAndSchema... schemas)	Drops all database objects in the passed schema(s).
final void	Liquibase.generateChangeLog(CatalogAndSchema catalogAndSchema, DiffToChangeLog changeLogWriter, PrintStream outputStream, Class<? extends DatabaseObject>... snapshotTypes)
final void	Liquibase.generateChangeLog(CatalogAndSchema catalogAndSchema, DiffToChangeLog changeLogWriter, PrintStream outputStream, ChangeLogSerializer changeLogSerializer, Class<? extends DatabaseObject>... snapshotTypes)
protected ChangeLogIterator	Liquibase.getStandardChangelogIterator(Contexts contexts, LabelExpression labelExpression, DatabaseChangeLog changeLog)	Return a ChangeLogIterator constructed with standard filters for processing the specified changelog.
boolean	Liquibase.isSafeToRunUpdate()	Returns true if it is "save" to migrate the database.
void	Liquibase.outputHeader(String message)	Deprecated. use {@link LoggingExecutorTextUtil#outputHeader(String, Database, String))}

Uses of DatabaseException in liquibase.changelog

Methods in liquibase.changelog that throw DatabaseException

Modifier and Type	Method	Description
protected void	OfflineChangeLogHistoryService.appendChangeSet(ChangeSet changeSet, ChangeSet.ExecType execType)
void	ChangeLogHistoryService.destroy()
void	MockChangeLogHistoryService.destroy()
void	OfflineChangeLogHistoryService.destroy()
void	StandardChangeLogHistoryService.destroy()
String	AbstractChangeLogHistoryService.getLastDeploymentId()	Returns the deployment ID of the last changeset that has been run, or null if no changesets have been run yet.
RanChangeSet	AbstractChangeLogHistoryService.getRanChangeSet(ChangeSet changeSet)
RanChangeSet	ChangeLogHistoryService.getRanChangeSet(ChangeSet changeSet)
RanChangeSet	MockChangeLogHistoryService.getRanChangeSet(ChangeSet changeSet)
RanChangeSet	StandardChangeLogHistoryService.getRanChangeSet(ChangeSet changeSet)
List<RanChangeSet>	ChangeLogHistoryService.getRanChangeSets()
default List<RanChangeSet>	ChangeLogHistoryService.getRanChangeSets(boolean allowChecksumsUpgrade)	Deprecated. use ChangeLogHistoryService.getRanChangeSets() instead
List<RanChangeSet>	MockChangeLogHistoryService.getRanChangeSets()
List<RanChangeSet>	MockChangeLogHistoryService.getRanChangeSets(boolean a)
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 run.
Date	MockChangeLogHistoryService.getRanDate(ChangeSet changeSet)
ChangeSet.RunStatus	AbstractChangeLogHistoryService.getRunStatus(ChangeSet changeSet)
ChangeSet.RunStatus	ChangeLogHistoryService.getRunStatus(ChangeSet changeSet)
ChangeSet.RunStatus	MockChangeLogHistoryService.getRunStatus(ChangeSet changeSet)
void	ChangeLogHistoryService.init()	Ensures the change log history container is correctly initialized for use.
void	MockChangeLogHistoryService.init()
void	OfflineChangeLogHistoryService.init()
void	StandardChangeLogHistoryService.init()
List<Map<String,?>>	StandardChangeLogHistoryService.queryDatabaseChangeLogTable(Database database)
void	ChangeLogHistoryService.removeFromHistory(ChangeSet changeSet)
void	MockChangeLogHistoryService.removeFromHistory(ChangeSet changeSet)
void	OfflineChangeLogHistoryService.removeFromHistory(ChangeSet changeSet)
void	StandardChangeLogHistoryService.removeFromHistory(ChangeSet changeSet)
protected void	OfflineChangeLogHistoryService.replaceChangeSet(ChangeSet changeSet, liquibase.changelog.OfflineChangeLogHistoryService.ReplaceChangeSetLogic replaceLogic)
void	AbstractChangeLogHistoryService.replaceChecksum(ChangeSet changeSet)
default void	ChangeLogHistoryService.replaceChecksum(ChangeSet changeSet)	By default does nothing to keep compatibility with older versions, but subclasses may like to implement this method to support checksum upgrades.
void	OfflineChangeLogHistoryService.replaceChecksum(ChangeSet changeSet)
void	ChangeLogHistoryService.setExecType(ChangeSet changeSet, ChangeSet.ExecType execType)
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.tag(String tagString)
void	MockChangeLogHistoryService.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	MockChangeLogHistoryService.tagExists(String tag)
boolean	OfflineChangeLogHistoryService.tagExists(String tag)
boolean	StandardChangeLogHistoryService.tagExists(String tag)
void	AbstractChangeLogHistoryService.upgradeChecksums(DatabaseChangeLog databaseChangeLog, Contexts contexts, LabelExpression labels)
void	ChangeLogHistoryService.upgradeChecksums(DatabaseChangeLog databaseChangeLog, Contexts contexts, LabelExpression labels)	Updates null checksum values
void	MockChangeLogHistoryService.upgradeChecksums(DatabaseChangeLog databaseChangeLog, Contexts contexts, LabelExpression labels)
void	StandardChangeLogHistoryService.upgradeChecksums(DatabaseChangeLog databaseChangeLog, Contexts contexts, LabelExpression labels)

Uses of DatabaseException in liquibase.changelog.filter

Constructors in liquibase.changelog.filter that throw DatabaseException

Modifier	Constructor	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	Description
DiffResult	DiffCommandStep.createDiffResult(CommandResultsBuilder resultsBuilder)
protected DatabaseSnapshot	DiffCommandStep.createReferenceSnapshot(CommandResultsBuilder resultsBuilder)
protected ChangeLogIterator	StatusCommandStep.getStandardChangelogIterator(Contexts contexts, LabelExpression labelExpression, DatabaseChangeLog changeLog, Database database)
ChangeLogIterator	UpdateCountCommandStep.getStandardChangelogIterator(CommandScope commandScope, Database database, Contexts contexts, LabelExpression labelExpression, DatabaseChangeLog databaseChangeLog)
ChangeLogIterator	UpdateCountCommandStep.getStatusChangelogIterator(CommandScope commandScope, Database database, Contexts contexts, LabelExpression labelExpression, DatabaseChangeLog databaseChangeLog)
ChangeLogIterator	UpdateToTagCommandStep.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	Description
protected Database	AbstractDatabaseConnectionCommandStep.createDatabaseObject(String url, String username, String password, String defaultSchemaName, String defaultCatalogName, String driver, String driverPropertiesFile, String liquibaseCatalogName, String liquibaseSchemaName)
Database	DbUrlConnectionCommandStep.obtainDatabase(CommandScope commandScope)	Try to retrieve and set the database object from the command scope, otherwise creates a new one .

Uses of DatabaseException in liquibase.database

Methods in liquibase.database that throw DatabaseException

Modifier and Type	Method	Description
protected boolean	AbstractJdbcDatabase.canCreateChangeLogTable()
default void	Database.checkDatabaseConnection()	Some databases (such as MongoDB) require you to verify the connection to the database to ensure that the database is accessible.
void	AbstractJdbcDatabase.close()
void	Database.close()
void	DatabaseConnection.close()
void	MockDatabaseConnection.close()
void	OfflineConnection.close()
void	AbstractJdbcDatabase.commit()
void	Database.commit()
void	DatabaseConnection.commit()
void	MockDatabaseConnection.commit()
void	OfflineConnection.commit()
DatabaseConnection	ConnectionServiceFactory.create(String url, Driver driverObject, Properties driverProperties)
PreparedStatement	PreparedStatementFactory.create(String sql)	Creates a PreparedStatement object for the specified SQL statement.
void	LiquibaseTableNames.destroy(Database database)
void	LiquibaseTableNamesFactory.destroy(Database abstractJdbcDatabase)
void	StandardLiquibaseTableNames.destroy(Database database)
boolean	AbstractJdbcDatabase.disableForeignKeyChecks()
boolean	Database.disableForeignKeyChecks()
boolean	AbstractJdbcDatabase.doesTagExist(String tag)
boolean	Database.doesTagExist(String tag)	Deprecated. Use ChangeLogHistoryService.tagExists(String) instead
void	AbstractJdbcDatabase.enableForeignKeyChecks()
void	Database.enableForeignKeyChecks()
Database	DatabaseFactory.findCorrectDatabaseImplementation(DatabaseConnection connection)
boolean	DatabaseConnection.getAutoCommit()
boolean	MockDatabaseConnection.getAutoCommit()
boolean	OfflineConnection.getAutoCommit()
String	DatabaseConnection.getCatalog()
String	MockDatabaseConnection.getCatalog()
String	OfflineConnection.getCatalog()
protected String	AbstractJdbcDatabase.getConnectionCatalogName()
int	AbstractJdbcDatabase.getDatabaseMajorVersion()
int	Database.getDatabaseMajorVersion()
int	DatabaseConnection.getDatabaseMajorVersion()
int	MockDatabaseConnection.getDatabaseMajorVersion()
int	OfflineConnection.getDatabaseMajorVersion()
int	AbstractJdbcDatabase.getDatabaseMinorVersion()
int	Database.getDatabaseMinorVersion()
int	DatabaseConnection.getDatabaseMinorVersion()
int	MockDatabaseConnection.getDatabaseMinorVersion()
int	OfflineConnection.getDatabaseMinorVersion()
String	DatabaseConnection.getDatabaseProductName()
String	MockDatabaseConnection.getDatabaseProductName()
String	OfflineConnection.getDatabaseProductName()
String	AbstractJdbcDatabase.getDatabaseProductVersion()
String	Database.getDatabaseProductVersion()
String	DatabaseConnection.getDatabaseProductVersion()
String	MockDatabaseConnection.getDatabaseProductVersion()
String	OfflineConnection.getDatabaseProductVersion()
RanChangeSet	AbstractJdbcDatabase.getRanChangeSet(ChangeSet changeSet)
RanChangeSet	Database.getRanChangeSet(ChangeSet changeSet)
List<RanChangeSet>	AbstractJdbcDatabase.getRanChangeSetList()
List<RanChangeSet>	Database.getRanChangeSetList()	Returns the ChangeSets that have been run against the current database.
Date	AbstractJdbcDatabase.getRanDate(ChangeSet changeSet)
Date	Database.getRanDate(ChangeSet changeSet)
ChangeSet.RunStatus	AbstractJdbcDatabase.getRunStatus(ChangeSet changeSet)
ChangeSet.RunStatus	Database.getRunStatus(ChangeSet changeSet)	Returns the run status for the given 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	MockDatabaseConnection.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 of the AbstractJdbcDatabase.isSafeToRunUpdate() method.
boolean	Database.isSafeToRunUpdate()
void	AbstractJdbcDatabase.markChangeSetExecStatus(ChangeSet changeSet, ChangeSet.ExecType execType)
void	Database.markChangeSetExecStatus(ChangeSet changeSet, ChangeSet.ExecType execType)	After the changeset has been run against the database this method will update the change log table with the information.
String	DatabaseConnection.nativeSQL(String sql)
String	MockDatabaseConnection.nativeSQL(String sql)
String	OfflineConnection.nativeSQL(String sql)
void	DatabaseConnection.open(String url, Driver driverObject, Properties driverProperties)
void	MockDatabaseConnection.open(String url, Driver driverObject, Properties driverProperties)
void	OfflineConnection.open(String url, Driver driverObject, Properties driverProperties)
DatabaseConnection	DatabaseFactory.openConnection(String url, String username, String password, String driver, String databaseClass, String driverPropertiesFile, String propertyProviderClass, ResourceAccessor resourceAccessor)
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)
Database	DatabaseFactory.openDatabase(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)
void	AbstractJdbcDatabase.removeRanStatus(ChangeSet changeSet)
void	Database.removeRanStatus(ChangeSet changeSet)
void	AbstractJdbcDatabase.rollback()
void	Database.rollback()
void	DatabaseConnection.rollback()
void	MockDatabaseConnection.rollback()
void	OfflineConnection.rollback()
void	AbstractJdbcDatabase.setAutoCommit(boolean b)
void	Database.setAutoCommit(boolean b)
void	DatabaseConnection.setAutoCommit(boolean autoCommit)
void	MockDatabaseConnection.setAutoCommit(boolean autoCommit)
void	OfflineConnection.setAutoCommit(boolean autoCommit)
void	Database.setDefaultCatalogName(String catalogName)
void	Database.setDefaultSchemaName(String schemaName)
boolean	AbstractJdbcDatabase.supportsBatchUpdates()
boolean	Database.supportsBatchUpdates()	Does the database support batched DML (INSERT/UPDATE/DELETE/MERGE/...) statements sent in a single call to the database?
void	AbstractJdbcDatabase.tag(String tagString)
void	Database.tag(String tagString)	Deprecated. Use ChangeLogHistoryService.tag(String) instead

Uses of DatabaseException in liquibase.database.core

Methods in liquibase.database.core that throw DatabaseException

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

Modifier and Type	Method	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	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	Description
void	DiffToReport.print()

Uses of DatabaseException in liquibase.exception

Subclasses of DatabaseException in liquibase.exception

Modifier and Type	Class	Description
class	StatementNotSupportedOnDatabaseException

Uses of DatabaseException in liquibase.executor

Methods in liquibase.executor that throw DatabaseException

Modifier and Type	Method	Description
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	AbstractExecutor.execute(Change change)
void	AbstractExecutor.execute(Change change, List<SqlVisitor> sqlVisitors)
void	Executor.execute(Change change)	Write methods
void	Executor.execute(Change change, List<SqlVisitor> sqlVisitors)
void	Executor.execute(SqlStatement sql)
void	Executor.execute(SqlStatement sql, List<SqlVisitor> sqlVisitors)
void	LoggingExecutor.execute(SqlStatement sql)
void	LoggingExecutor.execute(SqlStatement sql, List<SqlVisitor> sqlVisitors)
int	Executor.queryForInt(SqlStatement sql)	Executes a query that is expected to return a scalar (1 row, 1 column).
int	Executor.queryForInt(SqlStatement sql, List<SqlVisitor> sqlVisitors)	Applies a number of SqlVisitors to the sql query.
int	LoggingExecutor.queryForInt(SqlStatement sql)
int	LoggingExecutor.queryForInt(SqlStatement sql, List<SqlVisitor> sqlVisitors)
List<Map<String,?>>	Executor.queryForList(SqlStatement sql)	Executes a given SQL statement and returns a List of rows.
List	Executor.queryForList(SqlStatement sql, Class elementType)
List	Executor.queryForList(SqlStatement sql, Class elementType, 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.
List<Map<String,?>>	LoggingExecutor.queryForList(SqlStatement sql)
List	LoggingExecutor.queryForList(SqlStatement sql, Class elementType)
List	LoggingExecutor.queryForList(SqlStatement sql, Class elementType, List<SqlVisitor> sqlVisitors)
List<Map<String,?>>	LoggingExecutor.queryForList(SqlStatement sql, List<SqlVisitor> sqlVisitors)
long	Executor.queryForLong(SqlStatement sql)	Executes a query that is expected to return a scalar (1 row, 1 column).
long	Executor.queryForLong(SqlStatement sql, List<SqlVisitor> sqlVisitors)	Applies a number of SqlVisitors to the sql query.
long	LoggingExecutor.queryForLong(SqlStatement sql)
long	LoggingExecutor.queryForLong(SqlStatement sql, List<SqlVisitor> sqlVisitors)
<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	Executor.queryForObject(SqlStatement sql, Class<T> requiredType, List<SqlVisitor> sqlVisitors)	Applies a number of SqlVisitors to the sql query.
<T> T	LoggingExecutor.queryForObject(SqlStatement sql, Class<T> requiredType)
<T> T	LoggingExecutor.queryForObject(SqlStatement sql, Class<T> requiredType, List<SqlVisitor> sqlVisitors)
int	Executor.update(SqlStatement sql)
int	Executor.update(SqlStatement sql, List<SqlVisitor> sqlVisitors)
int	LoggingExecutor.update(SqlStatement sql)
int	LoggingExecutor.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	Description
void	JdbcExecutor.comment(String message)
static void	ChangelogJdbcMdcListener.execute(Database database, ChangelogJdbcMdcListener.ExecuteJdbc jdbcQuery)	Execute the given statement via the jdbc executor.
void	ChangelogJdbcMdcListener.ExecuteJdbc.execute(Executor executor)
T	ChangelogJdbcMdcListener.QueryJdbc.execute(Executor executor)
Object	JdbcExecutor.execute(liquibase.executor.jvm.CallableStatementCallback action, List<SqlVisitor> sqlVisitors)
Object	JdbcExecutor.execute(liquibase.executor.jvm.StatementCallback action, List<SqlVisitor> sqlVisitors)
void	JdbcExecutor.execute(SqlStatement sql)
void	JdbcExecutor.execute(SqlStatement sql, List<SqlVisitor> sqlVisitors)
void	SnowflakeJdbcExecutor.execute(SqlStatement sql, 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	Description
void	DatabaseTestSystem.execute(Change change)
void	DatabaseTestSystem.execute(SqlStatement sqlStatement)
void	DatabaseTestSystem.executeInverses(Change change)
Database	DatabaseTestSystem.getDatabaseFromFactory()

Uses of DatabaseException in liquibase.integration.cdi

Methods in liquibase.integration.cdi that throw DatabaseException

Modifier and Type	Method	Description
protected Database	CDILiquibase.createDatabase(Connection c)	Creates and returns a Database object retrieved from the DatabaseFactory.

Uses of DatabaseException in liquibase.integration.commandline

Methods in liquibase.integration.commandline that throw DatabaseException

Modifier and Type	Method	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	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	Description
protected Database	SpringLiquibase.createDatabase(Connection c, ResourceAccessor resourceAccessor)	Subclasses may override this method to modify the database settings, such as the 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	Description
void	LockService.destroy()
void	MockLockService.destroy()
void	OfflineLockService.destroy()
void	StandardLockService.destroy()
void	LockService.forceReleaseLock()	Releases whatever locks are on the database change log table
void	MockLockService.forceReleaseLock()
void	OfflineLockService.forceReleaseLock()
void	StandardLockService.forceReleaseLock()
void	LockService.init()
void	MockLockService.init()
void	OfflineLockService.init()
void	StandardLockService.init()
protected boolean	StandardLockService.isDatabaseChangeLogLockTableCreated()

Uses of DatabaseException in liquibase.report

Methods in liquibase.report that throw DatabaseException

Modifier and Type	Method	Description
void	RollbackReportParameters.setupDatabaseInfo(Database database)	Setup database related info used in rollback report.

Uses of DatabaseException in liquibase.snapshot

Methods in liquibase.snapshot that throw DatabaseException

Modifier and Type	Method	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.
protected List<CachedRow>	ResultSetCache.ResultSetExtractor.executeAndExtract(String sql, Database database)
protected List<CachedRow>	ResultSetCache.ResultSetExtractor.executeAndExtract(Database database, boolean informixTrimHint, String sql, Object... parameters)
protected List<CachedRow>	ResultSetCache.ResultSetExtractor.executeAndExtract(Database database, String sql, Object... parameters)
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)
boolean	SnapshotGeneratorFactory.hasIgnoreNested(DatabaseObject example, Database database)	Checks if a specific object is present in a 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	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.
<T extends DatabaseObject> T	SnapshotGeneratorChain.snapshot(T example, DatabaseSnapshot snapshot)	This calls all the non-replaced SnapshotGenerator in the chain, by comparison order Only the first generator in the chain is allowed to create a new instance of T Subsequent generators must modify the instance or call the chain if the provided object is not handled, otherwise a DatabaseException is thrown

Constructors in liquibase.snapshot that throw DatabaseException

Modifier	Constructor	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	Description
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)
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[]	SchemaSnapshotGenerator.getDatabaseSchemaNames(Database database)	Fetches an array of Strings with the schema names in the database.
protected String[]	SchemaSnapshotGeneratorSnowflake.getDatabaseSchemaNames(Database database)
protected List<Map<String,?>>	UniqueConstraintSnapshotGenerator.listColumns(UniqueConstraint example, Database database, DatabaseSnapshot snapshot)
protected List<Map<String,?>>	UniqueConstraintSnapshotGeneratorSnowflake.listColumns(UniqueConstraint example, Database database, DatabaseSnapshot snapshot)
protected List<CachedRow>	UniqueConstraintSnapshotGenerator.listConstraints(Table table, DatabaseSnapshot snapshot, Schema schema)
protected List<CachedRow>	UniqueConstraintSnapshotGeneratorSnowflake.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. name, type and default value.
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	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

Modifier and Type	Method	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	ExecutablePreparedStatement.execute(PreparedStatementFactory factory)	Executes the prepared statement created by the given factory.
void	ExecutablePreparedStatementBase.execute(PreparedStatementFactory factory)

Uses of DatabaseException in liquibase.util

Methods in liquibase.util that throw DatabaseException

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