Java Code Examples for org.flywaydb.core.Flyway#setLocations()

public void doMigrate(String table, String location) {
    logger.info("migrate : {}, {}", table, location);

    Flyway flyway = new Flyway();
    flyway.setPlaceholderPrefix("$${");
    // flyway.setInitOnMigrate(true);
    flyway.setBaselineOnMigrate(true);
    // flyway.setInitVersion("0");
    flyway.setBaselineVersionAsString("0");
    flyway.setDataSource(dataSource);
    flyway.setTable(table);
    flyway.setLocations(new String[] { location });

    try {
        flyway.repair();
    } catch (Exception ex) {
        logger.error(ex.getMessage(), ex);
    }

    flyway.migrate();
}
 

public static Flyway createFlyway(DataSource dataSource, String schema, List<String> locations, boolean validateOnMigrate) {
    int flywayVersion = FlywayClassUtils.getFlywayVersion();

    if (flywayVersion >= 60) {
        Object config = invokeStaticMethod(Flyway.class, "configure");
        invokeMethod(config, "dataSource", dataSource);
        invokeMethod(config, "schemas", (Object) new String[]{ schema });
        invokeMethod(config, "validateOnMigrate", validateOnMigrate);
        if (!CollectionUtils.isEmpty(locations)) {
            invokeMethod(config, "locations", (Object) locations.toArray(new String[0]));
        }
        return (Flyway) invokeMethod(config, "load");
    } else {
        Flyway flyway = new Flyway();
        flyway.setDataSource(dataSource);
        flyway.setSchemas(schema);
        flyway.setValidateOnMigrate(validateOnMigrate);
        if (!CollectionUtils.isEmpty(locations)) {
            flyway.setLocations(locations.toArray(new String[0]));
        }
        return flyway;
    }
}
 

private void flywayMigrate(DataSource dataSource) {
    boolean enabled = configuration.isFlywayEnabled();
    if (!enabled) {
        logger.debug("Flyway migrations are disabled");
        return;
    }


    Flyway flyway = new Flyway();
    configuration.getFlywayTable().ifPresent(tableName -> {
        logger.debug("Using Flyway migration table '{}'", tableName);
        flyway.setTable(tableName);
    });

    flyway.setLocations(Paths.get("db","migration_postgres").toString());
    flyway.setDataSource(dataSource);
    flyway.setPlaceholderReplacement(false);
    flyway.migrate();
}
 

@BeforeClass
public static void initMigration() throws SQLException {
    flyway = new Flyway();
    flyway.setDataSource(DB_URL, "sa", "");
    flyway.setLocations("filesystem:src/main/resources/db/migration");
    flyway.migrate();

    connection = flyway.getDataSource().getConnection();
    //add some data to test db cleanup
    try (Statement stmt = connection.createStatement()) {
        stmt.addBatch("INSERT INTO flyway_test.author(id, first_name, last_name, date_of_birth, year_of_birth, address) VALUES (1, 'Erich', 'Gamma','1903-06-25','1900',null)");
        stmt.addBatch("INSERT INTO flyway_test.author(id, first_name, last_name, date_of_birth, year_of_birth, address) VALUES (2, 'Richard', 'Helm','1903-06-25','1900',null)");
        int[] result = stmt.executeBatch();
        assertEquals(result.length, 2);
    }
}
 

public static Flyway get(StorageProviderConfiguration conf, String scriptRootPath) {
    Flyway flyway = new Flyway();

    String location = "filesystem:" + scriptRootPath;
    flyway.setEncoding(encoding);
    flyway.setTable(metaDataTableName);
    flyway.setValidateOnMigrate(validateOnMigrate);
    flyway.setOutOfOrder(outOfOrder);
    flyway.setBaselineOnMigrate(baselineOnMigrate);
    flyway.setBaselineVersion(MigrationVersion.fromVersion(baselineVersion));
    flyway.setCleanOnValidationError(cleanOnValidationError);
    flyway.setLocations(location);
    flyway.setResolvers(new ShellMigrationResolver(flyway.getConfiguration(), location, shellMigrationPrefix, shellMigrationSeperator, shellMigrationSuffix));
    flyway.setDataSource(conf.getUrl(), conf.getUser(), conf.getPassword(), null);

    return flyway;
}
 

private static Flyway basicFlyway(StorageProviderConfiguration conf,
                                  String scriptRootPath,
                                  boolean validateOnMigrate) {
    Flyway flyway = new Flyway();

    String location = "filesystem:" + scriptRootPath + File.separator + conf.getDbType();
    flyway.setEncoding(encoding);
    flyway.setTable(metaDataTableName);
    flyway.setSqlMigrationPrefix(sqlMigrationPrefix);
    flyway.setValidateOnMigrate(validateOnMigrate);
    flyway.setOutOfOrder(outOfOrder);
    flyway.setBaselineOnMigrate(baselineOnMigrate);
    flyway.setBaselineVersion(MigrationVersion.fromVersion(baselineVersion));
    flyway.setCleanOnValidationError(cleanOnValidationError);
    flyway.setLocations(location);

    return flyway;
}
 

@Test
public void migrateWithNoCallbacks() {
    logTestBoundary("migrateWithNoCallbacks");
    Flyway flyway = new Flyway();
    flyway.setDataSource(dataSource);
    flyway.setLocations("db/migration");
    flyway.migrate(); 
}
 

@Override
public void run() {
	// Perform Database Migration
	Flyway flyway = new Flyway();
	flyway.setBaselineOnMigrate(true);
	flyway.setLocations("io/andrewohara/tinkertime/db/migration");
	flyway.setDataSource(connectionString.getUrl(), null, null);
	try {
		flyway.migrate();
	} catch (FlywayException e){
		flyway.repair();
		throw e;
	}
}
 

@Override
public Map<String, String> init() throws SchemaInitializationException {
  final Map<String, String> initResult = new HashMap<>();
  try (final Connection conn = dataSource.getConnection()) {
    final Flyway flyway = new Flyway();
    flyway.setDataSource(dataSource);
    flyway.setLocations(locations);
    flyway.setClassLoader(Thread.currentThread().getContextClassLoader());
    final DbSupport dbSupport = DbSupportFactory.createDbSupport(conn, true);
    final MetaDataTable mt =
        new MetaDataTableImpl(
            dbSupport,
            dbSupport.getOriginalSchema().getTable(flyway.getTable()),
            flyway.getInstalledBy());
    initResult.put(BARE_DB_INIT_PROPERTY_NAME, String.valueOf(!mt.hasAppliedMigrations()));
    final String productName = conn.getMetaData().getDatabaseProductName().toLowerCase();
    flyway.setResolvers(
        new CustomSqlMigrationResolver(productName, dbSupport, placeholderReplacer));
    flyway.setSkipDefaultResolvers(true);
    flyway.setBaselineOnMigrate(baselineOnMigrate);
    if (baselineOnMigrate) {
      flyway.setBaselineVersionAsString(baselineVersion);
    }
    flyway.setSqlMigrationSeparator(versionSeparator);
    flyway.setSqlMigrationSuffix(scriptsSuffix);
    flyway.setSqlMigrationPrefix(scriptsPrefix);
    flyway.migrate();
  } catch (SQLException | RuntimeException x) {
    throw new SchemaInitializationException(x.getLocalizedMessage(), x);
  }
  return initResult;
}
 

@Test
public void testFlywayOnH2() throws IOException {
  Flyway flyway = new Flyway();
  flyway.setLocations("/db/h2");
  JdbcDataSource ds = new JdbcDataSource();
  File db = File.createTempFile("cassandra-reaper", "h2");
  try {
    ds.setUrl("jdbc:h2:" + db.getAbsolutePath() + ";MODE=PostgreSQL");
    flyway.setDataSource(ds);
    flyway.migrate();
  } finally {
    db.delete();
  }
}
 

@Test
public void migrateWithSqlAndJavaCallbacks() {
    logTestBoundary("migrateWithSqlAndJavaCallbacks");
    Flyway flyway = new Flyway();
    flyway.setDataSource(dataSource);
    flyway.setLocations("db/migration", "db/callbacks");
    flyway.setCallbacks(new ExampleFlywayCallback());
    flyway.migrate(); 
}
 

public static void migrate() {
    Flyway flyway = new Flyway();
    flyway.setDataSource(CMSConnectionPools.processing());
    flyway.setBaselineOnMigrate(true);
    flyway.setLocations("db/cms/migration");
    flyway.setSqlMigrationPrefix("V_");
    flyway.setTable("_flyway");
    flyway.migrate();
}
 

public static void main(String[] args) {
    Config config = ConfigFactory.load();

    Flyway flyway = new Flyway();
    flyway.setBaselineOnMigrate(true);
    flyway.setLocations(config.getString("migrations.location"));
    flyway.setDataSource(
            config.getString("jdbc.url"), 
            config.getString("jdbc.user"), 
            config.getString("jdbc.password"));
    flyway.migrate();
}
 

@Test
public void migrateWithSqlCallbacks() {
    logTestBoundary("migrateWithSqlCallbacks");
    Flyway flyway = new Flyway();
    flyway.setDataSource(dataSource);
    flyway.setLocations("db/migration", "db/callbacks");
    flyway.migrate(); 
}
 

private void flywayMigrate(DataSource dataSource) {

        Flyway flyway = new Flyway();
        flyway.setLocations(Paths.get("db","migration_postgres").toString());
        flyway.setDataSource(dataSource);
        flyway.setPlaceholderReplacement(false);
        flyway.migrate();
    }
 

public static void migrate() {
    Flyway flyway = new Flyway();
    flyway.setDataSource(CMSConnectionPools.processing());
    flyway.setBaselineOnMigrate(true);
    flyway.setLocations("db/cms/migration");
    flyway.setSqlMigrationPrefix("V_");
    flyway.setTable("_flyway");
    flyway.migrate();
}
 

private DataSource setDataSource(EmbeddedPostgres server) throws Exception {
  PGPoolingDataSource dataSource = new PGPoolingDataSource();
  dataSource.setUser("kloopzcm");
  dataSource.setPassword("testpwd");
  dataSource.setPortNumber(server.getPort());
  dataSource.setDatabaseName("kloopzdb");

  Flyway flyway = new Flyway();
  flyway.setPlaceholderReplacement(false);
  flyway.setLocations("classpath:deployer");
  flyway.setDataSource(dataSource);
  flyway.migrate();

  return dataSource;
}
 

protected static void setFlywayLocations(Flyway flyway, String[] locations) {
    if (flywayVersion >= 51) {
        Object configuration = getField(flyway, "configuration");
        invokeMethod(configuration, "setLocationsAsStrings", (Object) locations);
    } else {
        flyway.setLocations(locations);
    }
}
 

/**
 * @return H2 pooled data source
 * @throws SQLException
 */
@Bean(destroyMethod = "dispose")
public DataSource dataSource() throws SQLException {
	final JdbcConnectionPool pool = JdbcConnectionPool.create(url, user, password);
	pool.setMaxConnections(maxPoolConnections);
	Connection con = null;
	con = pool.getConnection();

	final Flyway flyway = new Flyway();
	flyway.setLocations("classpath:sql/migration");
	flyway.setDataSource(pool);
	flyway.setSqlMigrationPrefix("VOS-");
	flyway.setIgnoreFailedFutureMigration(true);

	final JdbcTemplate tpl = new JdbcTemplate(pool);
	if (tpl.queryForObject("select count(*) from information_schema.tables where table_name = 'LOG_SOURCES'",
			int.class) == 0) {
		logger.info("H2 database not found, creating new schema and populate with default data");
		flyway.setBaselineVersion(MigrationVersion.fromVersion(DB_SETUP_VERSION));
		flyway.setBaselineOnMigrate(true);
		try {
			final ResourceDatabasePopulator dbPopulator = new ResourceDatabasePopulator();
			dbPopulator.addScript(new ClassPathResource("/sql/quartz/tables_h2.sql"));
			dbPopulator.addScript(new ClassPathResource("/sql/model/schema_h2.sql"));
			dbPopulator.populate(con);
			newSchema = true;
			logger.info("Established H2 connection pool with new database");
		} finally {
			if (con != null) {
				con.close();
			}
		}
	} else {
		logger.info("Established H2 connection pool with existing database");
		if (tpl.queryForObject("select count(*) from information_schema.tables where table_name = 'schema_version'",
				int.class) == 0) {
			logger.info("Flyway's DB migration not setup in this version, set baseline version to 0.5.0");
			flyway.setBaselineVersion(MigrationVersion.fromVersion("0.5.0"));
			flyway.setBaselineOnMigrate(true);
		}
	}

	logger.debug("Migrating database, base version is: {}", flyway.getBaselineVersion());
	flyway.migrate();
	logger.debug("Database migrated from base version: {}", flyway.getBaselineVersion());

	return pool;
}
 

public void init(HibernateStorageSettings settings) {
    try {
        readWriteLock.writeLock().lock();
        migrationRequired = false;

        sfUpdateRequired = false;

        flyway = new Flyway();

        flyway.getPlaceholders().put("db_name", settings.getDbName());

        String[] initSqls = new String[0];

        if (settings.getDbms().equals(DbmsType.PostgreSQL.getValue())) {
            flyway.setLocations(PSQL_SCRIPT_LOCATION);
        }

        if (settings.getDbms().equals(DbmsType.MySql.getValue())) {
            flyway.setLocations(MYSQL_SCRIPT_LOCATION);
            initSqls = MYSQL_INIT_SQL;
        }

        flyway.setDataSource(settings.buildConnectionUrl(), settings.getUsername(), settings.getPassword(), initSqls);

        flyway.setBaselineOnMigrate(false);

        // Get info about migrations

        MigrationInfoService info = flyway.info();

        currentDbVersionInfo = info.current();

        pendingMigrationsInfo = info.pending();

        MigrationInfo[] all = info.all();

        // Checks

        if (currentDbVersionInfo == null) {
            migrationRequired = true;

            throw new OlderSchemaException("DB initialization is required");

        }

        if (pendingMigrationsInfo.length != 0) {
            migrationRequired = true;

            throw new OlderSchemaException("Migration to version "
                    + pendingMigrationsInfo[pendingMigrationsInfo.length - 1].getVersion().getVersion()
                    + " is required");

        }

        if (all.length != 0) {
            MigrationInfo lastKnown = all[all.length - 1];

            if(lastKnown.getState() == MigrationState.FUTURE_SUCCESS) {

                sfUpdateRequired = true;

                throw new NewerSchemaException("DB schema has newer version " + lastKnown.getVersion().getVersion()
                        + ". Upgrade this Sailfish instance to use it.");
            }
        }
    } finally {
        readWriteLock.writeLock().unlock();
    }
}