Package migratedb.v1.core.api.configuration

Class DefaultConfiguration

  • All Implemented Interfaces:
    Configuration
    public class DefaultConfiguration
extends Object
implements Configuration
    JavaBean-style configuration for MigrateDB. This configuration can then be passed to MigrateDB using the new MigrateDb(Configuration) constructor.

    • Constructor Detail

      • DefaultConfiguration

        public DefaultConfiguration()

      • DefaultConfiguration

        public DefaultConfiguration​(@Nullable ClassLoader classLoader)
        Parameters:
        classLoader - The ClassLoader to use for loading migrations, resolvers, etc. from the classpath. (default: Thread.currentThread().getContextClassLoader()). Nullable for compatibility.

      • DefaultConfiguration

        public DefaultConfiguration​(Configuration configuration)
        Creates a new configuration with the same values as this existing one.

    • Method Detail

      • asFluentConfiguration

        public FluentConfiguration asFluentConfiguration()
        Returns:
        Fluent interface that delegates to this configuration instance.

      • getLocations

        public List<Location> getLocations()
        Specified by:
        getLocations in interface Configuration
        Returns:
        The locations to scan recursively for migrations. The location type is determined by its prefix. Unprefixed locations or locations starting with classpath: point to a package on the classpath and may contain both SQL and Java-based migrations. Locations starting with filesystem: point to a directory on the filesystem, may only contain SQL migrations and are only scanned recursively down non-hidden directories. (default: classpath:db/migration)

      • getEncoding

        public Charset getEncoding()
        Specified by:
        getEncoding in interface Configuration
        Returns:
        The encoding of SQL migrations. (default: UTF-8)

      • getDefaultSchema

        public String getDefaultSchema()
        Specified by:
        getDefaultSchema in interface Configuration
        Returns:
        The default schema managed by MigrateDB. This schema name is case-sensitive. If not specified, but schemas is, MigrateDB uses the first schema in that list. If that is also not specified, MigrateDb uses the default schema for the database connection.

        Consequences:

        • This schema will be the one containing the schema history table.
        • This schema will be the default for the database connection (provided the database supports this concept) .
        (default: The first schema specified in getSchemas(), and failing that the default schema for the database connection)

      • getSchemas

        public List<String> getSchemas()
        Specified by:
        getSchemas in interface Configuration
        Returns:
        The schemas managed by MigrateDB. These schema names are case-sensitive. If not specified, MigrateDB uses the default schema for the database connection. If defaultSchemaName is not specified, then the first of this list also acts as default schema.

        Consequences:

        • MigrateDB will automatically attempt to create all these schemas, unless they already exist.
        (default: The default schema for the database connection)

      • getTable

        public String getTable()
        Specified by:
        getTable in interface Configuration
        Returns:
        The name of the schema history table that will be used by MigrateDB. By default, (single-schema mode) the schema history table is placed in the default schema for the connection provided by the datasource. When the migratedb.schemas property is set (multi-schema mode), the schema history table is placed in the first schema of the list. (default: migratedb_state)

      • getOldTable

        public String getOldTable()
        Specified by:
        getOldTable in interface Configuration
        Returns:
        The old table to convert into the format used by MigrateDB. Only used for the "liberate" command.

      • isLiberateOnMigrate

        public boolean isLiberateOnMigrate()
        Specified by:
        isLiberateOnMigrate in interface Configuration
        Returns:
        Whether the liberate command is automatically executed on migrate if the schema history table does not exist, but oldTable exists. (Default: true)

      • getTablespace

        public @Nullable String getTablespace()
        Specified by:
        getTablespace in interface Configuration
        Returns:
        The tablespace where to create the schema history table that will be used by MigrateDB. If not specified, MigrateDB uses the default tablespace for the database connection. This setting is only relevant for databases that do support the notion of tablespaces. Its value is simply ignored for all others.

      • getTarget

        public TargetVersion getTarget()
        Specified by:
        getTarget in interface Configuration
        Returns:
        The target version up to which MigrateDB should consider migrations. Migrations with a higher version number will be ignored. Special values:
        • current: Designates the current version of the schema
        • latest: The latest version of the schema, as defined by the migration with the highest version
        • <version>? (end with a '?'): Instructs MigrateDB not to fail if the target version doesn't exist. In this case, MigrateDB will go up to but not beyond the specified target (default: fail if the target version doesn't exist)
        Defaults to latest

      • isFailOnMissingTarget

        public boolean isFailOnMissingTarget()
        Specified by:
        isFailOnMissingTarget in interface Configuration
        Returns:
        Whether to fail if no migration with the configured target version exists (default: true)

      • getCherryPick

        public List<MigrationPattern> getCherryPick()
        Specified by:
        getCherryPick in interface Configuration
        Returns:
        The migrations that MigrateDb should consider when migrating. Leave empty to consider all available migrations. Migrations not in this list will be ignored.

      • isPlaceholderReplacement

        public boolean isPlaceholderReplacement()
        Specified by:
        isPlaceholderReplacement in interface Configuration
        Returns:
        Whether placeholders should be replaced. (default: true)

      • getSqlMigrationPrefix

        public String getSqlMigrationPrefix()
        Specified by:
        getSqlMigrationPrefix in interface Configuration
        Returns:
        The file name prefix for versioned SQL migrations. Versioned SQL migrations have the following file name structure: prefixVERSIONseparatorDESCRIPTIONsuffix, which using the defaults translates to V1.1__My_description.sql. (default: V)

      • getBaselineMigrationPrefix

        public String getBaselineMigrationPrefix()
        Specified by:
        getBaselineMigrationPrefix in interface Configuration
        Returns:
        The file name prefix for baseline migrations. Baseline migrations represent all migrations with version <= current baseline migration version while keeping older migrations if needed for upgrading older deployments. They have the following file name structure: prefixVERSIONseparatorDESCRIPTIONsuffix, which using the defaults translates to B1.1__My_description.sql. (default: B)

      • getRepeatableSqlMigrationPrefix

        public String getRepeatableSqlMigrationPrefix()
        Specified by:
        getRepeatableSqlMigrationPrefix in interface Configuration
        Returns:
        The file name prefix for repeatable SQL migrations. Repeatable SQL migrations have the following file name structure: prefixSeparatorDESCRIPTIONsuffix, which using the defaults translates to R__My_description.sql. (default: R)

      • getSqlMigrationSeparator

        public String getSqlMigrationSeparator()
        Specified by:
        getSqlMigrationSeparator in interface Configuration
        Returns:
        The file name separator for SQL migrations. SQL migrations have the following file name structure: prefixVERSIONseparatorDESCRIPTIONsuffix, which using the defaults translates to V1.1__My_description.sql. (default: __)

      • getSqlMigrationSuffixes

        public List<String> getSqlMigrationSuffixes()
        Specified by:
        getSqlMigrationSuffixes in interface Configuration
        Returns:
        The file name suffixes for SQL migrations. SQL migrations have the following file name structure: prefixVERSIONseparatorDESCRIPTIONsuffix, which using the defaults translates to V1_1__My_description.sql Multiple suffixes (like .sql,.pkg,.pkb) can be specified for easier compatibility with other tools such as editors with specific file associations. (default: .sql)

      • getJavaMigrations

        public List<JavaMigration> getJavaMigrations()
        Specified by:
        getJavaMigrations in interface Configuration
        Returns:
        The additional Java-based migrations. These are not Java-based migrations discovered through classpath scanning and instantiated by MigrateDB. Instead, these are manually added instances of JavaMigration. This is particularly useful when working with a dependency injection container, where you may want the DI container to instantiate the class and wire up its dependencies for you. An empty list if none. (default: none)

      • isIgnoreMissingMigrations

        public boolean isIgnoreMissingMigrations()
        Specified by:
        isIgnoreMissingMigrations in interface Configuration
        Returns:
        Ignore missing migrations when reading the schema history table. These are migrations that were performed by an older deployment of the application that are no longer available in this version. For example: we have migrations available on the classpath with versions 1.0 and 3.0. The schema history table indicates that a migration with version 2.0 (unknown to us) has also been applied. Instead of bombing out (fail fast) with an exception, a warning is logged and MigrateDB continues normally. This is useful for situations where one must be able to deploy a newer version of the application even though it doesn't contain migrations included with an older one anymore. Note that if the most recently applied migration is removed, MigrateDb has no way to know it is missing and will mark it as future instead. true to continue normally and log a warning, false to fail fast with an exception. (default: false)

      • isIgnoreIgnoredMigrations

        public boolean isIgnoreIgnoredMigrations()
        Specified by:
        isIgnoreIgnoredMigrations in interface Configuration
        Returns:
        Ignore ignored migrations when reading the schema history table. These are migrations that were added in between already migrated migrations in this version. For example: we have migrations available on the classpath with versions from 1.0 to 3.0. The schema history table indicates that version 1 was finished on 1.0.15, and the next one was 2.0.0. But with the next release a new migration was added to version 1: 1.0.16. Such scenario is ignored by migrate command, but by default is rejected by validate. When ignoreIgnoredMigrations is enabled, such case will not be reported by validate command. This is useful for situations where one must be able to deliver complete set of migrations in a delivery package for multiple versions of the product, and allows for further development of older versions. true to continue normally, false to fail fast with an exception. (default: false)

      • isIgnorePendingMigrations

        public boolean isIgnorePendingMigrations()
        Specified by:
        isIgnorePendingMigrations in interface Configuration
        Returns:
        Ignore pending migrations when reading the schema history table. These are migrations that are available but have not yet been applied. This can be useful for verifying that in-development migration changes don't contain any validation-breaking changes of migrations that have already been applied to a production environment, e.g. as part of a CI/CD process, without failing because of the existence of new migration versions. true to continue normally, false to fail fast with an exception. (default: false)

      • isIgnoreFutureMigrations

        public boolean isIgnoreFutureMigrations()
        Specified by:
        isIgnoreFutureMigrations in interface Configuration
        Returns:
        Ignore future migrations when reading the schema history table. These are migrations that were performed by a newer deployment of the application that are not yet available in this version. For example: we have migrations available on the classpath up to version 3.0. The schema history table indicates that a migration to version 4.0 (unknown to us) has already been applied. Instead of bombing out (fail fast) with an exception, a warning is logged and MigrateDB continues normally. This is useful for situations where one must be able to redeploy an older version of the application after the database has been migrated by a newer one. true to continue normally and log a warning, false to fail fast with an exception. (default: true)

      • getIgnoreMigrationPatterns

        public List<ValidatePattern> getIgnoreMigrationPatterns()
        Specified by:
        getIgnoreMigrationPatterns in interface Configuration
        Returns:
        Patterns of ignored migrations. Each pattern is of the form <migration_type>:<migration_state>. See the website for full details.

        Example: repeatable:missing,versioned:pending,*:failed

        (default: none)

      • isValidateMigrationNaming

        public boolean isValidateMigrationNaming()
        Specified by:
        isValidateMigrationNaming in interface Configuration
        Returns:
        Whether to validate migrations and callbacks whose scripts do not obey the correct naming convention. A failure can be useful to check that errors such as case sensitivity in migration prefixes have been corrected. false to continue normally, true to fail fast with an exception. (default: false)

      • isValidateOnMigrate

        public boolean isValidateOnMigrate()
        Specified by:
        isValidateOnMigrate in interface Configuration
        Returns:
        Whether to automatically call validate or not when running migrate. true if validate should be called. false if not. (default: true)

      • getBaselineVersion

        public Version getBaselineVersion()
        Specified by:
        getBaselineVersion in interface Configuration
        Returns:
        The version to tag an existing schema with when executing baseline. (default: 1)

      • getBaselineDescription

        public String getBaselineDescription()
        Specified by:
        getBaselineDescription in interface Configuration
        Returns:
        The description to tag an existing schema with when executing baseline. (default: << MigrateDB Baseline >>)

      • isBaselineOnMigrate

        public boolean isBaselineOnMigrate()
        Specified by:
        isBaselineOnMigrate in interface Configuration
        Returns:
        Whether to automatically call baseline when migrate is executed against a non-empty schema with no schema history table. This schema will then be initialized with the baselineVersion before executing the migrations. Only migrations above baselineVersion will then be applied.

        This is useful for initial MigrateDB production deployments on projects with an existing DB.

        Be careful when enabling this as it removes the safety net that ensures MigrateDB does not migrate the wrong database in case of a configuration mistake! (default: false)

      • isOutOfOrder

        public boolean isOutOfOrder()
        Specified by:
        isOutOfOrder in interface Configuration
        Returns:
        Whether migrations are allowed to be run "out of order". If you already have versions 1 and 3 applied, and now a version 2 is found, it will be applied too instead of being ignored. (default: false)

      • isSkipExecutingMigrations

        public boolean isSkipExecutingMigrations()
        Specified by:
        isSkipExecutingMigrations in interface Configuration
        Returns:
        Whether MigrateDB should skip actually executing the contents of the migrations and only update the schema history table. This should be used when you have applied a migration manually (via executing the sql yourself, or via an ide), and just want the schema history table to reflect this.

        Use in conjunction with cherryPick to skip specific migrations instead of all pending ones. (default: false)

      • getResolvers

        public List<MigrationResolver> getResolvers()
        Specified by:
        getResolvers in interface Configuration
        Returns:
        The custom MigrationResolvers to be used in addition to the built-in ones for resolving Migrations to apply. An empty list if none. (default: none)

      • isSkipDefaultResolvers

        public boolean isSkipDefaultResolvers()
        Specified by:
        isSkipDefaultResolvers in interface Configuration
        Returns:
        Whether default built-in resolvers should be skipped. If true, only custom resolvers are used. (default: false)

      • getDataSource

        public @Nullable ConnectionProvider getDataSource()
        Specified by:
        getDataSource in interface Configuration
        Returns:
        The data source to use to access the database. Must have the necessary privileges to execute DDL.

      • getConnectRetries

        public int getConnectRetries()
        Specified by:
        getConnectRetries in interface Configuration
        Returns:
        The maximum number of retries when attempting to connect to the database. After each failed attempt, MigrateDB will wait 1 second before attempting to connect again, up to the maximum number of times specified by * connectRetries. The interval between retries doubles with each subsequent attempt. (default: 0)

      • getConnectRetriesInterval

        public int getConnectRetriesInterval()
        Specified by:
        getConnectRetriesInterval in interface Configuration
        Returns:
        The maximum time between retries when attempting to connect to the database in seconds. This will cap the interval between connect retry to the value provided. (default: 120)

      • getInitSql

        public String getInitSql()
        Specified by:
        getInitSql in interface Configuration
        Returns:
        The SQL statements to run to initialize a new database connection immediately after opening it. (default: null)

      • getClassLoader

        public ClassLoader getClassLoader()
        Specified by:
        getClassLoader in interface Configuration
        Returns:
        The ClassLoader to use for loading migrations, resolvers, etc. from the classpath. (default: Thread.currentThread().getContextClassLoader() )

      • isMixed

        public boolean isMixed()
        Specified by:
        isMixed in interface Configuration
        Returns:
        Whether to allow mixing transactional and non-transactional statements within the same migration. Enabling this automatically causes the entire affected migration to be run without a transaction.

        Note that this is only applicable for PostgreSQL, Aurora PostgreSQL, SQL Server and SQLite which all have statements that do not run at all within a transaction. This is not to be confused with implicit transaction, as they occur in MySQL or Oracle, where even though a DDL statement was run within a transaction, the database will issue an implicit commit before and after its execution. true if mixed migrations should be allowed. false if an error should be thrown instead. (default: false)

      • getInstalledBy

        public String getInstalledBy()
        Specified by:
        getInstalledBy in interface Configuration
        Returns:
        The username that will be recorded in the schema history table as having applied the migration, or null for the current database user of the connection (default: null).

      • isGroup

        public boolean isGroup()
        Specified by:
        isGroup in interface Configuration
        Returns:
        Whether to group all pending migrations together in the same transaction when applying them (only recommended for databases with support for DDL transactions). true if migrations should be grouped. false if they should be applied individually instead. (default: false)

      • getLockRetryCount

        public int getLockRetryCount()
        Specified by:
        getLockRetryCount in interface Configuration
        Returns:
        The maximum number of retries when trying to obtain a lock. -1 indicates attempting to repeat indefinitely.

      • isFailOnMissingLocations

        public boolean isFailOnMissingLocations()
        Specified by:
        isFailOnMissingLocations in interface Configuration
        Returns:
        Whether to fail if a location specified in the migratedb.locations option doesn't exist. (default: false)

      • isOutputQueryResults

        public boolean isOutputQueryResults()
        Specified by:
        isOutputQueryResults in interface Configuration
        Returns:
        Whether MigrateDB should output a table with the results of queries when executing migrations. true to output the results table (default: true)

      • getResourceProvider

        public ResourceProvider getResourceProvider()
        Specified by:
        getResourceProvider in interface Configuration
        Returns:
        The custom ResourceProvider to be used to look up resources. If not set, the default strategy will be used. (default: null)

      • isCreateSchemas

        public boolean isCreateSchemas()
        Specified by:
        isCreateSchemas in interface Configuration
        Returns:
        Whether MigrateDB should attempt to create the schemas specified in the schemas property. (default: true)

      • getCallbacks

        public List<Callback> getCallbacks()
        Specified by:
        getCallbacks in interface Configuration
        Returns:
        The callbacks for lifecycle notifications. An empty list if none. (default: none)

      • isSkipDefaultCallbacks

        public boolean isSkipDefaultCallbacks()
        Specified by:
        isSkipDefaultCallbacks in interface Configuration
        Returns:
        Whether default built-in callbacks should be skipped. If true, only custom callbacks are used. (default: false)

      • setGroup

        public void setGroup​(boolean group)
        Whether to group all pending migrations together in the same transaction when applying them (only recommended for databases with support for DDL transactions).

      • setInstalledBy

        public void setInstalledBy​(String installedBy)
        The username that will be recorded in the schema history table as having applied the migration.

      • setLogger

        public void setLogger​(LogSystem logger)
        The log system MigrateDB should use.

      • setLogger

        public void setLogger​(String... logger)
        The log system(s) MigrateDB should use.

      • setMixed

        public void setMixed​(boolean mixed)
        Whether to allow mixing transactional and non-transactional statements within the same migration. Enabling this automatically causes the entire affected migration to be run without a transaction.

        Note that this is only applicable for PostgreSQL, Aurora PostgreSQL, SQL Server and SQLite which all have statements that do not run at all within a transaction. This is not to be confused with implicit transaction, as they occur in MySQL or Oracle, where even though a DDL statement was run within a transaction, the database will issue an implicit commit before and after its execution.

      • setIgnoreMissingMigrations

        public void setIgnoreMissingMigrations​(boolean ignoreMissingMigrations)
        Ignore missing migrations when reading the schema history table. These are migrations that were performed by an older deployment of the application that are no longer available in this version. For example: we have migrations available on the classpath with versions 1.0 and 3.0. The schema history table indicates that a migration with version 2.0 (unknown to us) has also been applied. Instead of bombing out (fail fast) with an exception, a warning is logged and MigrateDB continues normally. This is useful for situations where one must be able to deploy a newer version of the application even though it doesn't contain migrations included with an older one anymore. Note that if the most recently applied migration is removed, MigrateDB has no way to know it is missing and will mark it as future instead.

      • setIgnoreIgnoredMigrations

        public void setIgnoreIgnoredMigrations​(boolean ignoreIgnoredMigrations)
        Ignore ignored migrations when reading the schema history table. These are migrations that were added in between already migrated migrations in this version. For example: we have migrations available on the classpath with versions from 1.0 to 3.0. The schema history table indicates that version 1 was finished on 1.0.15, and the next one was 2.0.0. But with the next release a new migration was added to version 1: 1.0.16. Such scenario is ignored by migrate command, but by default is rejected by validate. When ignoreIgnoredMigrations is enabled, such case will not be reported by validate command. This is useful for situations where one must be able to deliver complete set of migrations in a delivery package for multiple versions of the product, and allows for further development of older versions.

      • setIgnorePendingMigrations

        public void setIgnorePendingMigrations​(boolean ignorePendingMigrations)
        Ignore pending migrations when reading the schema history table. These are migrations that are available but have not yet been applied. This can be useful for verifying that in-development migration changes don't contain any validation-breaking changes of migrations that have already been applied to a production environment, e.g. as part of a CI/CD process, without failing because of the existence of new migration versions.

      • setIgnoreFutureMigrations

        public void setIgnoreFutureMigrations​(boolean ignoreFutureMigrations)
        Whether to ignore future migrations when reading the schema history table. These are migrations that were performed by a newer deployment of the application that are not yet available in this version. For example: we have migrations available on the classpath up to version 3.0. The schema history table indicates that a migration to version 4.0 (unknown to us) has already been applied. Instead of bombing out (fail fast) with an exception, a warning is logged and MigrateDB continues normally. This is useful for situations where one must be able to redeploy an older version of the application after the database has been migrated by a newer one.

      • setIgnoreMigrationPatternsAsStrings

        public void setIgnoreMigrationPatternsAsStrings​(String... ignoreMigrationPatterns)
        Ignore migrations that match this list of patterns when validating migrations. Each pattern is of the form <migration_type>:<migration_state>. See the website for full details.

        Example: repeatable:missing,versioned:pending,*:failed

      • setIgnoreMigrationPatternsAsStrings

        public void setIgnoreMigrationPatternsAsStrings​(Collection<String> ignoreMigrationPatterns)
        Ignore migrations that match this list of patterns when validating migrations. Each pattern is of the form <migration_type>:<migration_state>. See the website for full details.

        Example: repeatable:missing,versioned:pending,*:failed

      • setIgnoreMigrationPatterns

        public void setIgnoreMigrationPatterns​(ValidatePattern... ignoreMigrationPatterns)
        Ignore migrations that match the given ValidatePatterns when validating migrations.

      • setIgnoreMigrationPatterns

        public void setIgnoreMigrationPatterns​(Collection<ValidatePattern> ignoreMigrationPatterns)
        Ignore migrations that match the given ValidatePatterns when validating migrations.

      • setValidateMigrationNaming

        public void setValidateMigrationNaming​(boolean validateMigrationNaming)
        Whether to validate migrations and callbacks whose scripts do not obey the correct naming convention. A failure can be useful to check that errors such as case sensitivity in migration prefixes have been corrected.

      • setValidateOnMigrate

        public void setValidateOnMigrate​(boolean validateOnMigrate)
        Whether to automatically call validate or not when running migrate.

      • setLocationsAsStrings

        public void setLocationsAsStrings​(String... locations)
        Sets the locations to scan recursively for migrations. The location type is determined by its prefix. Unprefixed locations or locations starting with classpath: point to a package on the classpath and may contain both SQL and Java-based migrations. Locations starting with filesystem: point to a directory on the filesystem, may only contain SQL migrations and are only scanned recursively down non-hidden directories.

      • setLocationsAsStrings

        public void setLocationsAsStrings​(Collection<String> locations)
        Sets the locations to scan recursively for migrations. The location type is determined by its prefix. Unprefixed locations or locations starting with classpath: point to a package on the classpath and may contain both SQL and Java-based migrations. Locations starting with filesystem: point to a directory on the filesystem, may only contain SQL migrations and are only scanned recursively down non-hidden directories.

      • setLocations

        public void setLocations​(Location... locations)
        Sets the locations to scan recursively for migrations. The location type is determined by its prefix. Unprefixed locations or locations starting with classpath: point to a package on the classpath and may contain both SQL and Java-based migrations. Locations starting with filesystem: point to a directory on the filesystem, may only contain SQL migrations and are only scanned recursively down non-hidden directories.

      • setLocations

        public void setLocations​(Collection<Location> locations)
        Sets the locations to scan recursively for migrations. The location type is determined by its prefix. Unprefixed locations or locations starting with classpath: point to a package on the classpath and may contain both SQL and Java-based migrations. Locations starting with filesystem: point to a directory on the filesystem, may only contain SQL migrations and are only scanned recursively down non-hidden directories.

      • setEncoding

        public void setEncoding​(Charset encoding)
        Sets the encoding of SQL migrations.

      • setEncodingAsString

        public void setEncodingAsString​(String encoding)
        Sets the encoding of SQL migrations.

      • setDefaultSchema

        public void setDefaultSchema​(String schema)
        Sets the default schema managed by MigrateDB. This schema name is case-sensitive. If not specified, but Schemas is, MigrateDB uses the first schema in that list. If that is also not specified, MigrateDb uses the default schema for the database connection.

        Consequences:

        • This schema will be the one containing the schema history table.
        • This schema will be the default for the database connection (provided the database supports this concept) .

      • setSchemas

        public void setSchemas​(String... schemas)
        Sets the schemas managed by MigrateDB. These schema names are case-sensitive. If not specified, MigrateDB uses the default schema for the database connection. If defaultSchema is not specified, then the first of this list also acts as default schema.

        Consequences:

        • MigrateDB will automatically attempt to create all these schemas, unless they already exist.

      • setSchemas

        public void setSchemas​(Collection<String> schemas)
        Sets the schemas managed by MigrateDB. These schema names are case-sensitive. If not specified, MigrateDB uses the default schema for the database connection. If defaultSchema is not specified, then the first of this list also acts as default schema.

        Consequences:

        • MigrateDB will automatically attempt to create all these schemas, unless they already exist.
        s

      • setTable

        public void setTable​(String table)
        Sets the name of the schema history table that will be used by MigrateDB. By default (single-schema mode) the schema history table is placed in the default schema for the connection provided by the datasource. When the migratedb.schemas property is set (multi-schema mode), the schema history table is placed in the first schema of the list.

      • setOldTable

        public void setOldTable​(String oldTable)
        Sets the name of the old table to convert into the format used by MigrateDB. Only used for the "liberate" command.

      • setTablespace

        public void setTablespace​(@Nullable String tablespace)
        Sets the tablespace where to create the schema history table that will be used by MigrateDB. If not specified, MigrateDb uses the default tablespace for the database connection.This setting is only relevant for databases that do support the notion of tablespaces. Its value is simply ignored for all others.

      • setTarget

        public void setTarget​(TargetVersion target)
        Sets the target version up to which MigrateDB should consider migrations. Migrations with a higher version number will be ignored. Special values:
        • current: Designates the current version of the schema
        • latest: The latest version of the schema, as defined by the migration with the highest version
        • next: The next version of the schema, as defined by the first pending migration
        Defaults to latest.

      • setTargetAsString

        public void setTargetAsString​(String target)
        Sets the target version up to which MigrateDB should consider migrations. Migrations with a higher version number will be ignored. Special values:
        • current: Designates the current version of the schema
        • latest: The latest version of the schema, as defined by the migration with the highest version
        • next: The next version of the schema, as defined by the first pending migration
        • <version>? (end with a '?'): Instructs MigrateDB not to fail if the target version doesn't exist. In this case, MigrateDb will go up to but not beyond the specified target (default: fail if the target version doesn't exist)
        Defaults to latest.

      • setFailOnMissingTarget

        public void setFailOnMissingTarget​(boolean failOnMissingTarget)
        Whether to fail if no migration with the configured target version exists (default: true)

      • setCherryPick

        public void setCherryPick​(MigrationPattern... cherryPick)
        Sets the migrations that MigrateDB should consider when migrating. Leave empty to consider all available migrations. Migrations not in this list will be ignored.

      • setCherryPick

        public void setCherryPick​(Collection<MigrationPattern> cherryPick)
        Sets the migrations that MigrateDB should consider when migrating. Leave empty to consider all available migrations. Migrations not in this list will be ignored.

      • setCherryPickAsString

        public void setCherryPickAsString​(String... cherryPickAsString)
        Sets the migrations that MigrateDB should consider when migrating. Leave empty to consider all available migrations. Migrations not in this list will be ignored. Values should be the version for versioned migrations (e.g. 1, 2.4, 6.5.3) or the description for repeatable migrations (e.g. Insert_Data, Create_Table)

      • setCherryPickAsString

        public void setCherryPickAsString​(Collection<String> cherryPickAsString)
        Sets the migrations that MigrateDB should consider when migrating. Leave empty to consider all available migrations. Migrations not in this list will be ignored. Values should be the version for versioned migrations (e.g. 1, 2.4, 6.5.3) or the description for repeatable migrations (e.g. Insert_Data, Create_Table)

      • setPlaceholderReplacement

        public void setPlaceholderReplacement​(boolean placeholderReplacement)
        Sets whether placeholders should be replaced.

      • setPlaceholders

        public void setPlaceholders​(Map<String,​String> placeholders)
        Sets the placeholders to replace in SQL migration scripts.

      • setPlaceholderPrefix

        public void setPlaceholderPrefix​(String placeholderPrefix)
        Sets the prefix of every placeholder.

      • setScriptPlaceholderPrefix

        public void setScriptPlaceholderPrefix​(String scriptPlaceholderPrefix)
        Sets the prefix of every script placeholder.

      • setPlaceholderSuffix

        public void setPlaceholderSuffix​(String placeholderSuffix)
        Sets the suffix of every placeholder.

      • setScriptPlaceholderSuffix

        public void setScriptPlaceholderSuffix​(String scriptPlaceholderSuffix)
        Sets the suffix of every placeholder.

      • setSqlMigrationPrefix

        public void setSqlMigrationPrefix​(String sqlMigrationPrefix)
        Sets the file name prefix for SQL migrations. SQL migrations have the following file name structure: prefixVERSIONseparatorDESCRIPTIONsuffix, which using the defaults translates to V1_1__My_description.sql

      • setBaselineMigrationPrefix

        public void setBaselineMigrationPrefix​(String baselineMigrationPrefix)
        Sets the file name prefix for baseline migrations. They have the following file name structure: prefixVERSIONseparatorDESCRIPTIONsuffix, which using the defaults translates to B1__My_description.sql

      • setJavaMigrations

        public void setJavaMigrations​(JavaMigration... javaMigrations)
        The additional Java-based migrations. These are not Java-based migrations discovered through classpath scanning and instantiated by MigrateDB. Instead, these are application-managed instances of JavaMigration. This is particularly useful when working with a dependency injection container, where you may want the DI container to instantiate the class and wire up its dependencies for you.

      • setJavaMigrations

        public void setJavaMigrations​(Collection<JavaMigration> javaMigrations)
        The additional Java-based migrations. These are not Java-based migrations discovered through classpath scanning and instantiated by MigrateDB. Instead, these are application-managed instances of JavaMigration. This is particularly useful when working with a dependency injection container, where you may want the DI container to instantiate the class and wire up its dependencies for you.

      • setRepeatableSqlMigrationPrefix

        public void setRepeatableSqlMigrationPrefix​(String repeatableSqlMigrationPrefix)
        Sets the file name prefix for repeatable SQL migrations. Repeatable SQL migrations have the following file name structure: prefixSeparatorDESCRIPTIONsuffix, which using the defaults translates to R__My_description.sql

      • setSqlMigrationSeparator

        public void setSqlMigrationSeparator​(String sqlMigrationSeparator)
        Sets the file name separator for SQL migrations. SQL migrations have the following file name structure: prefixVERSIONseparatorDESCRIPTIONsuffix, which using the defaults translates to V1_1__My_description.sql

      • setSqlMigrationSuffixes

        public void setSqlMigrationSuffixes​(String... sqlMigrationSuffixes)
        The file name suffixes for SQL migrations. (default: .sql) SQL migrations have the following file name structure: prefixVERSIONseparatorDESCRIPTIONsuffix, which using the defaults translates to V1_1__My_description.sql Multiple suffixes (like .sql,.pkg,.pkb) can be specified for easier compatibility with other tools such as editors with specific file associations.

      • setSqlMigrationSuffixes

        public void setSqlMigrationSuffixes​(Collection<String> sqlMigrationSuffixes)
        The file name suffixes for SQL migrations. (default: .sql) SQL migrations have the following file name structure: prefixVERSIONseparatorDESCRIPTIONsuffix, which using the defaults translates to V1_1__My_description.sql Multiple suffixes (like .sql,.pkg,.pkb) can be specified for easier compatibility with other tools such as editors with specific file associations.

      • setDataSource

        public void setDataSource​(@Nullable DataSource dataSource)
        Sets the data source to use. Must have the necessary privileges to execute DDL.

      • setDataSource

        public void setDataSource​(@Nullable ConnectionProvider dataSource)
        Sets the data source to use. Must have the necessary privileges to execute DDL.

      • setConnectRetries

        public void setConnectRetries​(int connectRetries)
        The maximum number of retries when attempting to connect to the database. After each failed attempt, MigrateDB will wait 1 second before attempting to connect again, up to the maximum number of times specified by connectRetries. The interval between retries doubles with each subsequent attempt.

      • setConnectRetriesInterval

        public void setConnectRetriesInterval​(int connectRetriesInterval)
        The maximum time between retries when attempting to connect to the database in seconds. This will cap the interval between connect retry to the value provided.

      • setInitSql

        public void setInitSql​(String initSql)
        The SQL statements to run to initialize a new database connection immediately after opening it.

      • setBaselineVersion

        public void setBaselineVersion​(Version baselineVersion)
        Sets the version to tag an existing schema with when executing baseline.

      • setBaselineVersionAsString

        public void setBaselineVersionAsString​(String baselineVersion)
        Sets the version to tag an existing schema with when executing baseline.

      • setBaselineDescription

        public void setBaselineDescription​(String baselineDescription)
        Sets the description to tag an existing schema with when executing baseline.

      • setBaselineOnMigrate

        public void setBaselineOnMigrate​(boolean baselineOnMigrate)
        Whether to automatically call baseline when migrate is executed against a non-empty schema with no schema history table. This schema will then be baselined with the baselineVersion before executing the migrations. Only migrations above baselineVersion will then be applied.

        This is useful for initial MigrateDB production deployments on projects with an existing DB.

        Be careful when enabling this as it removes the safety net that ensures MigrateDB does not migrate the wrong database in case of a configuration mistake!

      • setOutOfOrder

        public void setOutOfOrder​(boolean outOfOrder)
        Allows migrations to be run "out of order". If you already have versions 1 and 3 applied, and now a version 2 is found, it will be applied too instead of being ignored.

      • setSkipExecutingMigrations

        public void setSkipExecutingMigrations​(boolean skipExecutingMigrations)
        Whether MigrateDB should skip actually executing the contents of the migrations and only update the schema history table. This should be used when you have applied a migration manually (via executing the sql yourself, or via an IDE), and just want the schema history table to reflect this.

        Use in conjunction with cherryPick to skip specific migrations instead of all pending ones.

      • setCallbacks

        public void setCallbacks​(Callback... callbacks)
        Set the callbacks for lifecycle notifications.

      • setCallbacks

        public void setCallbacks​(Collection<Callback> callbacks)
        Set the callbacks for lifecycle notifications.

      • setCallbacksAsClassNames

        public void setCallbacksAsClassNames​(String... callbacks)
        Set the callbacks for lifecycle notifications.

      • setCallbacksAsClassNames

        public void setCallbacksAsClassNames​(Collection<String> callbacks)
        Set the callbacks for lifecycle notifications.

      • useExtension

        public void useExtension​(MigrateDbExtension extension)
        Enables a single MigrateDB extension.

      • useExtensions

        public void useExtensions​(Iterable<MigrateDbExtension> extensions)
        Enables multiple MigrateDB extensions. This is mainly used to load extensions from the ServiceLoader facility: 
        
      config.useExtensions(ServiceLoader.load(MigrateDbExtension.class))

      • setSkipDefaultCallbacks

        public void setSkipDefaultCallbacks​(boolean skipDefaultCallbacks)
        Whether MigrateDB should skip the default callbacks. If true, only custom callbacks are used.

      • setResolvers

        public void setResolvers​(MigrationResolver... resolvers)
        Sets custom MigrationResolvers to be used in addition to the built-in ones for resolving Migrations to apply.

      • setResolvers

        public void setResolvers​(Collection<MigrationResolver> resolvers)
        Sets custom MigrationResolvers to be used in addition to the built-in ones for resolving Migrations to apply.

      • setResolversAsClassNames

        public void setResolversAsClassNames​(String... resolvers)
        Sets custom MigrationResolvers to be used in addition to the built-in ones for resolving Migrations to apply.

      • setResolversAsClassNames

        public void setResolversAsClassNames​(Collection<String> resolvers)
        Sets custom MigrationResolvers to be used in addition to the built-in ones for resolving Migrations to apply.

      • setSkipDefaultResolvers

        public void setSkipDefaultResolvers​(boolean skipDefaultResolvers)
        Whether MigrateDB should skip the default resolvers. If true, only custom resolvers are used.

      • setCreateSchemas

        public void setCreateSchemas​(boolean createSchemas)
        Whether MigrateDB should attempt to create the schemas specified in the schemas property.

      • setOutputQueryResults

        public void setOutputQueryResults​(boolean outputQueryResults)
        Whether MigrateDB should output a table with the results of queries when executing migrations.

      • setResourceProvider

        public void setResourceProvider​(ResourceProvider resourceProvider)
        Set the custom ResourceProvider to be used to look up resources. If not set, the default strategy will be * used. (default: null)

      • setJavaMigrationClassProvider

        public void setJavaMigrationClassProvider​(ClassProvider<JavaMigration> javaMigrationClassProvider)
        The custom ClassProvider to be used to look up JavaMigration classes. If not set, the default * strategy will be used. (default: null)

      • setLockRetryCount

        public void setLockRetryCount​(int lockRetryCount)
        Sets the maximum number of retries when trying to obtain a lock. -1 indicates attempting to repeat indefinitely.

      • setFailOnMissingLocations

        public void setFailOnMissingLocations​(boolean failOnMissingLocations)
        Whether to fail if a location specified in the migratedb.locations option doesn't exist

      • setLiberateOnMigrate

        public void setLiberateOnMigrate​(boolean liberateOnMigrate)
        Whether the liberate command is automatically executed on migrate if the schema history table does not exist, but oldTable exists. (Default: true)

      • setExtensionConfig

        public <T extends ExtensionConfig> void setExtensionConfig​(Class<T> extensionConfigType,
                                                           T value)
        Sets the extension config of type T.

      • configure

        public void configure​(Configuration configuration)
        Configure with the same values as this existing configuration.

        To use a custom ClassLoader, it must be passed to the constructor prior to calling this method.

      • configure

        public void configure​(Properties properties)
        Configures MigrateDB with these properties. This overwrites any existing configuration. Property names are documented in PropertyNames. To use a custom ClassLoader, it must be passed to the MigrateDB constructor prior to calling this method. To support the configuration of extensions, those extensions must be activated via useExtension prior to calling this method.
        Parameters:
        properties - Properties used for configuration.
        Throws:
        MigrateDbException - if the configuration fails.

      • configure

        public void configure​(Map<String,​String> props)
        Configures MigrateDB with these properties. This overwrites any existing configuration. Property names are documented in PropertyNames. To use a custom ClassLoader, it must be passed to the MigrateDB constructor prior to calling this method. To support the configuration of extensions, those extensions must be activated via useExtension prior to calling this method.
        Parameters:
        props - Properties used for configuration.
        Throws:
        MigrateDbException - if the configuration fails.