All Classes and Interfaces

Class
Description
 
Standard superclass to simplify Change implementations.
 
 
 
 
 
 
 
Deprecated. 
Deprecated.
Implement commands with CommandStep and call them with CommandFactory.getCommandDefinition(String...).
Convenience base class for CommandStep implementations.
Deprecated.
 
Convenience base class for ConfigurationValueProvider implementations
Abstract CommandStep providing database connectivity.
 
Template class for all types of database objects can be manipulated using ChangeSets.
 
Code common to all Executor services / blueprint for Executor service classes.
Convenience class implementing ExtensibleObject.
 
 
Class to hold all methods that are common to helper classes
AbstractJdbcDatabase is extended by all supported databases as a facade to the underlying database.
A Liquibase MOJO that requires the user to provide a DatabaseChangeLogFile to be able to perform any actions on the database.
A base class for providing Liquibase Policy Checks functionality.
 
A base class for providing Liquibase Liquibase functionality.
 
Liquibase Update Maven plugin.
Convenience base implementation of a Logger.
Convenience base implementation of a LoggerFactory.
Convenience class for ConfigurationValueProviders that can collect the possible values into a Map.
Encapsulates common fields for update and delete changes.
 
Convenience base class for PathHandlers.
 
Convenience base class for Plugin implementations.
Convenience base class for all factories that find correct Plugin implementations.
 
 
Convenience base class for ResourceAccessor implementations.
AbstractRollbackCommandStep provides the common operations to all the rollback* commands.
A common parent for all raw SQL related changes regardless of where the sql was sourced from.
 
Generic template class for an SQL generator able to generate SQL for an object-form SqlStatement.
 
 
 
 
 
 
Deprecated.
 
Makes an existing column into an auto-increment column.
 
 
 
 
 
This class provides a workaround for adding auto increment for SQLite since SQLite does not support it
 
Adds a column to an existing table.
 
 
 
 
Workaround for adding column on existing table for SQLite.
 
Sets a new default value to an existing column.
 
 
 
 
 
 
Adds functionality for setting the sequence to be owned by the column with the default value
Workaround for Adding default value for SQLite
 
 
 
Adds a foreign key constraint to an existing column.
 
 
Extracts data from an existing column to create a lookup table.
Adds a NOT NULL constraint to an existing column.
Creates a primary key out of an existing column or set of columns.
 
 
 
Adds a unique constraint to an existing column.
 
 
 
 
 
 
Modifies properties of an existing sequence.
 
 
Container class for all preconditions on a change log.
 
An implementation of the Liquibase logger that logs to the given Ant task.
An implementation of the Liquibase LogService that logs all messages to the given Ant task.
 
 
 
 
 
Marker interface for a class containing ConfigurationDefinition which should be auto-loaded at Liquibase startup.
 
Base class for all Ant Liquibase tasks.
Performance-optimised version of ExecutablePreparedStatementBase.
Dummy SQL generator for $BatchDmlExecutablePreparedStatement
Signifies that a public API (public class, method or field) is subject to incompatible changes, or even removal, in a future release.
Represents a signed integer number using 64 bits of storage.
 
 
Deprecated.
use BOMInputStream instead
Deprecated.
 
Various utility methods for working with boolean objects.
Deprecated.
Deprecated.
Deprecated.
 
 
 
 
 
 
Object representing a database catalog and schema.
 
 
 
 
CDI Bootstrap
CDI Bootstrap
A CDI wrapper for Liquibase.
A CDI wrapper for Liquibase.
Holds the configuration for Liquibase
Holds the configuration for Liquibase
Interface all changes (refactorings) implement.
 
 
 
 
 
 
 
 
 
 
An implementation of ChangeExecListener can be called by UpdateVisitor or RollbackVisitor for each changeset that is actually run.
Creates a ChangeExecListener or utilizes the one provided as argument
 
Factory class for constructing the correct liquibase.change.Change implementation based on a command name.
 
 
 
 
 
 
 
 
 
The ChangeLogIterator class is responsible for iterating through a list of ChangeSets in a DatabaseChangeLog and executing a visitor for each ChangeSet that passes the specified filters.
A wrapper utility class around the standard JdbcExecutor used to monitor and log sql from Jdbc queries
 
 
 
 
Holds the parameters configured for a DatabaseChangeLog.
 
 
Defines the methods a class which is able to parse a Liquibase changelog file must support.
Deprecated.
Use correctly spelled version
Configuration container for properties applicable to most ChangeLogParser implementations
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Static metadata about a link Change.
 
Static metadata about a Change parameter.
Encapsulates a changeSet and all its associated changes.
 
 
 
 
 
 
The ChangSetService allows for creation and modification of ChangeSets to be pluggable The implemented createChangeSet methods support calls from the Liquibase Core to create Change Sets.
Create the appropriate ChangeSetService instance
 
 
Contains the current status of a ChangeSet.
Custom MDC object to represent the changesets that were deployed during an update event.
Called by ChangeLogIterator when a ChangeSetFilter accept a changeSet.
 
 
 
 
Factory class for constructing the liquibase.change.ChangeVisitor implementation based on a change name.
Markers a Change class as containing one or more ColumnConfig configuration.
 
CheckSums are used by liquibase to determine if a Change has been modified since it was originally ran.
Enum used to keep track of Liquibase Checksum versions introduced to enable the support of multiple versions at the same time.
An implementation of DirectoryResourceAccessor that builds up the file roots based on the passed ClassLoader.
Interface implemented by CommandSteps when they need to execute clean up tasks (such as closing database connections, flushing files, etc.) after other steps in the pipeline are executed.
 
 
 
 
 
 
 
 
 
 
Service class that centralizes database specific auto increment parameters information.
 
The standard configuration used by Change classes to represent a column.
 
 
 
RowMapper implementation that creates a java.util.Map for each row, representing all columns as key-value pairs: one entry for each column, with the column name as key.
Used to indicate what type of relation owns a column.
 
 
Informix-specific parts of ColumnSnapshotGenerator to account for various quirks in IBM Informix.
Oracle Database-specific parts of ColumnSnapshotGenerator
 
Deprecated.
Used by the old LiquibaseCommand style of command setup.
Defines a known, type-safe argument for a specific CommandStep.
A new CommandArgumentDefinition under construction from CommandBuilder
Builder for configuring CommandStep settings, such as CommandArgumentDefinitions and CommandResultDefinitions
Metadata about a particular command.
Deprecated.
Used by the old LiquibaseCommand style of command setup.
 
Manages the command related implementations.
CommandFailedException is thrown any time a command did not succeed.
 
Deprecated. 
Common Utility methods used in the CommandLine application and the Maven plugin.
Used to indicate that this CommandStep is intentionally overriding another CommandStep.
Deprecated.
Used by the old LiquibaseCommand style of command setup.
Defines a known, type-safe result from a specific CommandStep.
 
The results of CommandScope.execute().
Because CommandResults is immutable, this class is used to build up the results during CommandStep.run(CommandResultsBuilder).
The primary facade used for executing commands.
Defines a particular step in a command pipeline.
Deprecated.
Used by the old LiquibaseCommand style of command setup.
Exception thrown when any pre-execution validation fails.
 
 
A common place to store commonly used command argument names.
DatabaseObjectComparator for Catalog and Schema comparators with common stuff
 
 
 
 
 
 
A ResourceAccessor that contains multiple sub-accessors and combines the results of all of them.
Used for handling multiple UI output services.
Marker interface to indicate that a SqlStatement can generate different Sql which should be specifically executed
 
Deprecated.
interface from old style configuration code.
A higher-level/detailed definition to provide type-safety, metadata, default values, etc.
Used to construct new ConfigurationDefinition instances.
 
Deprecated. 
Used by ConfigurationDefinition.getCurrentConfiguredValue() to translate whatever object type a ConfigurationValueProvider is returning into the object type the definition uses.
Deprecated. 
Used by ConfigurationDefinition.getCurrentValueObfuscated() to obfuscate the current value.
Defines a way for LiquibaseConfiguration to find configured values.
 
This wraps all the ProvidedValues to return the overall value returned from the collection of ConfigurationValueProviders.
Provides a way for LiquibaseConfiguration to modify configured values.
Factory for working with ConfiguredValueModifiers.
A base class that holds connection string patterns with connection credentials that should be hidden in logs.
 
 
 
UIService implementation that sends messages to stdout and stderr.
Wrapper around Console to allow replacements as needed.
The standard configuration used by Change classes to represent a constraints on a column.
 
 
Encapsulates logic for evaluating if a set of runtime contexts matches a context expression string.
Wrapper for list of contexts.
 
 
 
 
 
 
 
 
Creates an index on an existing column.
 
Firebird-specific CREATE INDEX SQL generator.
 
 
 
 
 
Creates a new sequence.
 
 
 
Creates a new table.
 
An Informix-specific create table statement generator.
 
Creates a new view.
 
 
 
 
 
 
Interface to implement when creating a custom change.
Interface to implement that allows a custom change to generate its own checksum.
 
Adapts CustomChange implementations to the standard change system used by Liquibase.
 
 
Callback interface that accepts a single input argument and returns no result.
Marker interface that identifies an object as a custom object used in MDC.
 
Thrown when a precondition failed.
Thrown when a precondition failed.
 
Interface to implement when creating a custom change that generates SQL.
Interface to implement that allows rollback of a custom sql change.
Interface to implement when creating a custom change that does not actually generate SQL.
Interface to implement that allows rollback of a custom task change.
 
 
 
Interface that every DBMS supported by this software must implement.
Annotation used by AbstractChange to declare ChangeMetaData information.
Encapsulates the information stored in the change log XML file.
Controls what to do when including a file with a format that isn't recognized by a changelog parser.
This helper class provides two objects: a valid and verified DatabaseChangeLog and the ChangeLogParameters object used to instantiate it.
Information about the database changelog lock which allows only one instance of Liquibase to attempt to update a database at a time.
 
Container object which allows multiple DatabaseChangeProperty annotations to be used on a single property.
Annotation used by AbstractChange to declare ChangeParameterMetaData information.
A liquibase abstraction over the normal Connection that is available in java.sql.
This class represents a native data type used by a specific RDBMS.
 
 
 
 
 
 
 
 
 
Interface for all types of database objects can be manipulated using ChangeSets.
 
 
 
 
 
 
 
Ant task for rolling back a database.
 
 
Base class for TestSystems for databases.
 
Ant task for migrating a database forward.
Ant task for migrating a database forward testing rollback.
 
Wraps the external database used by DatabaseTestSystem so that HOW the database is interacted with is independent of WHAT we do with that connection.
 
 
Specifies the unit of a column's size.
 
 
A wrapper class for data types.
 
 
 
 
 
 
 
 
 
 
 
 
Precondition for specifying the type of database (oracle, mysql, etc.).
Adding this interface to your Change class allows you to specify a dbms attribute listing the databases the change is applied to.
This class contains only the arguments used by DbUrlConnectionCommandStep.
Internal command step to be used on CommandStep pipeline to manage the database connection.
 
A wrapper ChangeExecListener who keeps track of deployed and failed ChangeSets, while also delegating listener actions to any other ChangeExecListener included when the object is constructed.
 
Default input handler simply calls ObjectUtil.convert(Object, Class)
Deprecated.
not in use anywhere in Liquibase code and has been superseded by log-level and its associated command line parameters
 
 
 
 
 
 
 
 
 
 
Deprecated. 
 
 
 
 
 
Deprecated.
Implement commands with CommandStep and call them with CommandFactory.getCommandDefinition(String...).
 
 
 
 
 
 
 
Internal command step to be used on pipeline to instantiate a DiffOutputControl object that is mainly used by diffChangeLog/generateChangeLog .
 
 
 
 
Deprecated.
Implement commands with CommandStep and call them with CommandFactory.getCommandDefinition(String...).
 
PathHandler that converts the path into a DirectoryResourceAccessor.
A @{link ResourceAccessor} implementation for files on the file system.
Implementation of DatabaseWrapper for databases that are managed via docker in JdbcDatabaseContainers.
 
 
 
 
 
 
Drops an existing column from a table.
 
 
Removes the default value from an existing column.
 
 
 
Drops an existing foreign key constraint.
 
 
Drops an existing index.
 
 
Drops a not-null constraint from an existing column.
Removes an existing primary key.
 
 
 
 
 
 
Drops an existing sequence.
 
 
Drops an existing table.
 
 
Removes an existing unique constraint.
 
 
Drops an existing view.
 
 
 
 
 
 
 
Input stream that does not read (skips) lines starting with commentPattern and line endings.
 
Searches for the configuration values in the system environment variables.
 
 
 
To be implemented by instances that use a prepared statement for execution
 
 
 
Executes a given shell executable.
 
Interface for a class that is capable of executing statements/queries against a DBMS.
 
This interface marks an exception as one which can specify the exit code that Liquibase should use if an exception which implements this interface is thrown.
 
Common functionality for matching set of Context/Labels against provided expression.
This interface defines how objects can be extended with additional attributes at runtime without subclassing and exposes the ability to query attributes without resorting to reflection.
Annotation that can be added to fields in AbstractExtensibleObject to configure ObjectMetaData.Attribute information about it.
 
Service to perform a fast check of the historyService to determine if there is no unrun changesets without obtaining an exclusive write lock.
General filename and filepath manipulation utilities.
Deprecated.
 
 
Firebird database implementation.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Deprecated.
Implement commands with CommandStep and call them with CommandFactory.getCommandDefinition(String...).
 
 
 
 
 
 
 
 
 
 
 
 
 
Snowflake-specific view definition generator.
 
 
 
Deprecated.
Configuration container for global properties.
 
 
 
Display help information on liquibase-maven-plugin.
Call mvn liquibase:help -Ddetail=true -Dgoal=<goal-name> to display parameter details.
 
 
 
Deprecated.
Implement commands with CommandStep and call them with CommandFactory.getCommandDefinition(String...).
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Analyses the properties of a database index and creates an object representation ("snapshot").
 
 
 
Created by martoccia.i on 19/10/2016.
 
 
 
A list of InputStreams.
Inserts data into an existing table.
Dummy SQL generator for InsertDataChange.ExecutableStatement
Handles INSERT Execution
 
 
 
 
 
 
 
 
 
 
 
Adds an ON CONFLICT REPLACE clause to an INSERT INTO ... statement for SQLite.
 
 
 
 
 
Stores information about the integration running Liquibase.
Marker interface for liquibase.database.InternalDatabase implementations that are for internal Liquibase usage, not user-exposed databases.
 
Represents a signed integer number using 32 bits of storage.
 
Thrown if a descriptive example is not specific enough to perform a snapshot.
 
The default logger for Liquibase.
 
A ConnectionWrapper implementation which delegates completely to an underlying java.sql.connection.
 
 
Implementation of DatabaseWrapper for databases that are connected to via a JDBC url and are not "started" in a traditional sense.
Class to simplify execution of SqlStatements.
 
 
Deprecated.
 
 
 
 
 
Wrapper for list of labels.
 
 
encapsulates overall install result and any messages.
 
 
This class provides a static method for verifying licenses
 
 
Primary facade class for interacting with Liquibase.
Marks all unapplied changes to the database as applied in the change log.
Generates SQL that marks all unapplied changes as applied.
Marks all unapplied changes up to and include a specified tag to the database as applied in the change log.
Generates SQL that marks all unapplied changes up to and including a specified tag as applied.
Check the changelog for issues
List available checks, their configuration options, and current settings
Clears all checksums in the current changelog, so they will be recalculated next update.
This class is just a marker class that is used to distinguish columns that are used in the DATABASECHANGELOG and DATABASECHANGELOGLOCK tables from other columns that might be used in Liquibase-managed database schemas.
Deprecated.
Define command with the new CommandStep interface
 
 
Common configuration settings for integrations
 
Provides unified management of configuration properties within Liquibase core and in extensions.
Test connection to the configured database.
Generates a diff between the specified database and the reference database.
Object representing a data type, instead of a plain string.
List all rows from the Liquibase Pro 'DATABASECHANGELOGHISTORY' tracking table.
Generates dbDocs against the database.
Drops all database objects in the configured schema(s).
Finds the Liquibase schema from the classpath rather than fetching it over the Internet.
Base class for all Liquibase exceptions.
 
Run a series of commands contained in one or more stages, as configured in a liquibase flow-file.
Validate a series of commands contained in one or more stages, as configured in a liquibase flow-file.
Generates the SQL that is required to rollback the database to current state after the next update.
Generates a changelog based on the current database schema.
 
Outputs history of deployments against the configured database.
 
 
 
 
 
 
Launcher which builds up the classpath needed to run Liquibase, then calls LiquibaseCommandLine.main(String[]).
Base interface for all the different listeners available in liquibase.
Lists all Liquibase updater locks on the current database.
 
 
Removes any Liquibase updater locks from the current database.
Prints which changesets need to be applied to the database.
Invokes Liquibase to rollback the database (and mark changesets as unapplied).
 
Reverts (rolls back) one non-sequential changeSet made during a previous change to your database.
Displays the SQL which will be executed when the corresponding rollbackOneChangeSet command is executed.
Rolls back all changesets from any specific update, if all changesets can be rolled back.
Displays the SQL which will be executed when the corresponding rollbackOneUpdate command is executed.
Generates the SQL that is required to rollback the database using one or more of the specified attributes 'rollbackCount', 'rollbackTag' and/or 'rollbackDate'
 
 
 
 
 
 
 
Version of GenericServletListener that uses javax.servlet and NOT jakarta.servlet
The snapshot command captures the current state of the url database, which is the target database.
 
Version of GenericStatusServlet that uses javax.servlet and NOT jakarta.servlet
 
 
Writes a Liquibase tag to the database.
Checks for existence of the specified Liquibase tag in the database
Qualifier Annotation
Qualifier Annotation
Print a list of changesets that have been executed but are not in the current changelog
Applies the DatabaseChangeLogs to the database.
Generates the SQL that is required to update the database to the current version as specified in the DatabaseChangeLogs.
Applies the DatabaseChangeLogs to the database, testing rollback.
 
Validates liquibase changelog
 
 
 
 
 
 
 
A Location is an object that has a name, and value, used to represent a license.
 
 
 
 
Internal command step to be used on CommandStep pipeline to create lock services.
 
Deprecated.
use StandardLockService instead
 
 
Interface to class that does the actual logging.
Sends all UI requests to the configured Logger.
 
A variant of the Executor service that does not actually modify the target database(s).
Write texts to the current logging executor
Deprecated.
No longer used for filtering log messages.
This service is used to create named Logger instances through a LogService.
 
 
Deprecated.
use liquibase.integration.commandline.LiquibaseCommandLine.
 
Encapsulates MySQL database support.
 
 
 
 
 
 
 
 
 
Extension of ClassLoaderResourceAccessor for Maven which will use a default or user specified ClassLoader to load files/resources.
 
A Utilities class for Maven plugins.
Generates md5-sums based on a string.
 
 
 
 
 
 
 
 
Combines data from two existing columns into a new column and drops the original columns.
 
 
 
 
 
 
 
 
Exception indicating that the required argument is missing.
 
 
 
 
 
 
 
A DBMS that effectively does nothing, but it is useful for tests where everything should work in the same way for all databases.
 
 
 
 
 
Container class to handle the modifyChangeSets tag.
 
 
 
Encapsulates MS-SQL database support.
 
 
A wrapper of Liquibase suitable in multi-tenant environments where multiple data sources represent tenants.
Encapsulates MySQL database support.
 
 
 
 
 
Logger which does nothing with the log records it is provided.
Log service for the NoOpLogger which does nothing with the log records it is provided.
Default MDC manager, which does nothing.
Deprecated.
 
 
Class for controling "not" logic in preconditions.
 
Handles 'NOW' and 'TODAY' for Date / Time type columns
 
Miscellaneous utility methods for number conversion and parsing.
Deprecated.
 
 
 
 
 
 
 
 
 
 
Contains metadata about an ExtensibleObject.
Metadata about a particular attribute.
Strategy regards quoting object names e.g. table, column, index names etc.
 
Various methods that make it easier to read and write object properties using the propertyName, instead of having to look up the correct reader/writer methods manually first.
 
 
 
Defines the options for opening Resources in Liquibase.
 
Encapsulates Oracle database support.
 
Class for controlling "or" logic in preconditions.
 
 
 
The OutputFileHandler interface defines methods for handling log output files in Liquibase.
 
This helper class can be run prior to any command (but usually the *-sql commands, like update-sql) to redirect the SQL to the console, rather than running it against an actual database.
Acts as a standard abstract syntax layer for changelogs defined in different formats.
 
This exception is thrown when parse errors are encountered.
Interface for extensions that can translate path strings into ResourceAccessors and InputStreams.
Singleton for working with PathHandlers.
 
 
 
 
Interface for objects designed to be pluggable in Liquibase.
Interface for classes that manage Plugins.
Encapsulates PostgreSQL database support.
 
Prepares objects used by database comparison Commands like diff, diffChangelog, etc
Marker interface for preconditions.
 
 
 
 
Thrown when a problem occurs in the evaluation of a precondition (which, under normal circumstances, should never happen).
 
Thrown when a precondition failed.
Marker interface for precondition logic tags (and,or, not)
Factory for PreparedStatements
 
 
 
 
 
 
 
Annotation used at the field level that indicates that field is liquibase property element
 
Describes a value found from a provider.
Encapsulates information about a previously-ran changeset.
 
 
 
 
 
Allows execution of arbitrary SQL.
 
Marker interface for Reference Database providers used by CommandStep Framework.
This helper class can be run prior to any command (but usually the *-sql commands, like update-sql) to redirect the SQL to the console, rather than running it against an actual database.
The provided dependency.
Internal command step to be used on pipeline to manage the database connection to the reference database.
 
 
 
 
A container of columns.
 
 
 
Renames an existing column.
 
 
Renames an existing table.
 
 
Renames an existing table.
 
 
 
Renames an existing view.
 
 
 
 
 
ReplaceIfExists interface will control whether an implementation change object class will set the replaceIfExists flag that basically will tell generate-changelog/diffToChangelog commands the given change object needs to generate the SQL for replace the stored logic if it already exists
 
 
ResourceAccessors abstract file access so they can be read in a variety of environments.
 
 
 
 
 
 
 
 
 
 
 
 
RollbackCommandStep performs the rollback-to-tag logic.
 
 
 
 
Thrown if a change is encountered that cannot be rolled back.
 
 
 
RollbackSqlCommandStep performs the rollback-to-tag-sql logic.
This class is used to represent MDC data related to a sqlFile type change inside a rollback.
 
 
 
 
An interface used by Executor for mapping rows of a ResultSet on a per-row basis.
Adapter implementation of the ResultSetExtractor interface that delegates to a RowMapper which is supposed to create a not null constraint object for each row.
Adapter implementation of the ResultSetExtractor interface that delegates to a RowMapper which is supposed to create an object for each row.
Precondition that checks the name of the user executing the change log.
 
 
 
 
 
 
 
 
 
 
 
 
This scope object is used to hold configuration and other parameters within a call without needing complex method signatures.
Enumeration containing standard attributes.
 
 
 
Searches the Scope for the given key.
This should generally be the overall ResourceAccessor used by integrations.
 
 
 
 
 
 
 
 
 
Represents a function for getting the current value from a sequence
 
Represents a function for getting the next value from a sequence
Snapshot generator for a SEQUENCE object in a JDBC-accessible database
 
Abstraction for finding and creating instances of classes.
 
 
 
 
 
 
 
 
 
 
 
 
Setup class allowing registration of custom configuration value providers, and also providing automatic cleanup.
If there is an error with setting up a Change this Exception will be thrown.
 
 
 
This class encapsulates the argument "show-summary", which applies to the update family of commands.
 
 
Methods to show a summary of change set counts after an update
Internal use only filter.
An implementation of interface CharStream, where the stream is assumed to contain only ASCII characters (without unicode processing).
An Simple SQL Grammar.
Token literal values and constants.
Token Manager.
 
 
 
 
Called by ChangeLogIterator when a ChangeSetFilter rejects a changeSet.
 
Implementation of Map with the added methods SmartMap.get(String, Class) and SmartMap.get(String, Object) to make the return values type safe and/or auto-converted.
This class provides methods that are necessary because older (< 1.32) versions of SnakeYaml do not have those methods.
Deprecated.
Implement commands with CommandStep and call them with CommandFactory.getCommandDefinition(String...).
 
Allows the class user to influence various aspects of the database object snapshot generation, e.g.
 
 
 
 
Listener interface to be called during the snapshot process.
 
 
 
 
 
 
 
 
When running against Localstack Snowflake, you may need to add the following to your run configuration: --add-opens=java.base/java.nio=ALL-UNNAMED.
A Spring-ified wrapper for Liquibase.
 
 
 
Configuration container for global properties.
Represents a Change for custom SQL stored in a File.
SqlGenerator implementations take a database-independent SqlStatement interface and create a database-specific Sql object.
 
SqlGeneratorFactory is a singleton registry of SqlGenerators.
 
 
 
Liquibase listener for executed SQL
Deprecated.
load the LiquibaseSqlParser using the SqlParserFactory directly.
 
 
The SqlStatement classes correspond to (roughly) a single SQL statement.
 
 
 
 
The standard OSS implementation of the ChangeSetService
 
 
 
 
This class is used by other classes to filter the set of database objects used in diff-type operations including the diff command and the generateChangeLog command.
The Filter class is used internally to do the actual work.
 
Standard Liquibase behavior of redirecting console output to output-file.
 
 
 
 
 
 
 
 
This class calculates the status of all change sets involved in an update operation It allows us to determine ALL reasons that a ChangeSet will not be deployed, unlike the standard iterator which breaks upon finding a reason to deny the change set.
 
ChangeSetVisitor that will collect the execution status of changeSets without executing them.
 
 
 
 
 
 
 
Utilities for working with streams.
 
 
Defines a list of clauses that can be manipulated and rearranged based on keys associated with each.
 
 
 
 
 
 
 
 
Deprecated.
use StringUtils instead
 
 
 
Enum to control the level of validation to check if a change's supports method is properly implemented.
A SybaseASA specific Delegate that removes the calls to nativeSQL due to driver issues.
Support for SAP (formerly: Sybase) AS (Adapter Server) Anywhere embedded/mobile database.
 
A Sybase specific Delegate that removes the calls to commit and rollback as Sybase requires that autocommit be set to true.
Encapsulates Sybase ASE database support.
Searches for the configuration values in the system properties System.getProperties().
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
This class maintains an object quoting strategy and will reset the database's strategy when the close method is called.
 
 
 
TestSystem implementations define and manage a connection to an external system to test.
 
 
Factory for getting TestSystem implementations.
 
 
Deprecated.
ScopeManager now uses ThreadLocal to prevent concurrent modification issues.
 
Data type support for TIMESTAMP data types in various DBMS.
 
 
Describes the input token stream.
Token Manager Error.
Service for interacting with the user.
Enum used to define the available UIServices provided by Liquibase that can be set using global parameters
 
 
 
 
 
Marks an internal error (runtime exception) that prevents this software from further processing.
 
 
 
 
 
 
 
Deprecated.
will remove when all TestSystems are created.
 
 
 
 
 
 
 
 
 
Thrown by SnapshotParserFactory if it cannot find a parser for a given file format.
Container for a data type that is not covered by any implementation in liquibase.datatype.core.
 
 
 
 
 
 
 
 
 
 
 
Dummy SQL generator for UpdateDataChange.ExecutableStatement
 
 
 
 
 
 
This class is the representation of the summary available in the update command.
Container to handle sharing update summary message between different services
 
 
 
 
 
 
 
 
 
 
Similar to assert logic, but will run regardless of JVM settings.
 
 
An interface for generating validating visitors, which are used to validate changesets.
 
Util class to offload methods that are used by ValidatingVisitor class and may make it more complex than it should be
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Various utility methods for working with XML.
 
 
 
 
 
 
 
 
 
 
 
PathHandler that converts the path into a DirectoryResourceAccessor.