Examples with MigrationVersion org.flywaydb.core.api.MigrationVersion used on opensource projects

Example 16 with MigrationVersion

use of org.flywaydb.core.api.MigrationVersion in project flyway by flyway.

the class MyCustomMigrationResolver method resolveMigrations.

@Override
public List<ResolvedMigration> resolveMigrations() {
    List<ResolvedMigration> resolvedMigrations = new ArrayList<ResolvedMigration>();
    resolvedMigrations.add(new ResolvedMigration() {

        @Override
        public MigrationVersion getVersion() {
            return MigrationVersion.fromVersion("1.9");
        }

        @Override
        public String getDescription() {
            return "Virtual Migration";
        }

        @Override
        public String getScript() {
            return "VirtualScript 1.9";
        }

        @Override
        public Integer getChecksum() {
            return 19;
        }

        @Override
        public MigrationType getType() {
            return MigrationType.CUSTOM;
        }

        @Override
        public String getPhysicalLocation() {
            return "virtual://loaction";
        }

        @Override
        public MigrationExecutor getExecutor() {
            return new MigrationExecutor() {

                @Override
                public void execute(Connection connection) {
                    System.out.println("Executed !");
                }

                @Override
                public boolean executeInTransaction() {
                    return true;
                }
            };
        }
    });
    return resolvedMigrations;
}

Example 17 with MigrationVersion

use of org.flywaydb.core.api.MigrationVersion in project flyway by flyway.

the class SapHanaMigrationMediumTest method statistics.

@Test
public void statistics() throws Exception {
    flyway.setLocations("migration/dbsupport/saphana/sql/statistics");
    flyway.migrate();
    MigrationVersion version = flyway.info().current().getVersion();
    assertEquals("1", version.toString());
    assertEquals("Statistics", flyway.info().current().getDescription());
    flyway.clean();
    flyway.migrate();
}

Example 18 with MigrationVersion

use of org.flywaydb.core.api.MigrationVersion in project flyway by flyway.

the class MigrationInfoServiceImpl method refresh.

/**
     * Refreshes the info about all known migrations from both the classpath and the DB.
     */
public void refresh() {
    Collection<ResolvedMigration> availableMigrations = migrationResolver.resolveMigrations();
    List<AppliedMigration> appliedMigrations = metaDataTable.allAppliedMigrations();
    MigrationInfoContext context = new MigrationInfoContext();
    context.outOfOrder = outOfOrder;
    context.pending = pending;
    context.missing = missing;
    context.future = future;
    context.target = target;
    Map<MigrationVersion, ResolvedMigration> resolvedMigrationsMap = new TreeMap<MigrationVersion, ResolvedMigration>();
    Map<String, ResolvedMigration> resolvedRepeatableMigrationsMap = new TreeMap<String, ResolvedMigration>();
    for (ResolvedMigration resolvedMigration : availableMigrations) {
        MigrationVersion version = resolvedMigration.getVersion();
        if (version != null) {
            if (version.compareTo(context.lastResolved) > 0) {
                context.lastResolved = version;
            }
            resolvedMigrationsMap.put(version, resolvedMigration);
        } else {
            resolvedRepeatableMigrationsMap.put(resolvedMigration.getDescription(), resolvedMigration);
        }
    }
    Map<MigrationVersion, Pair<AppliedMigration, Boolean>> appliedMigrationsMap = new TreeMap<MigrationVersion, Pair<AppliedMigration, Boolean>>();
    List<AppliedMigration> appliedRepeatableMigrations = new ArrayList<AppliedMigration>();
    for (AppliedMigration appliedMigration : appliedMigrations) {
        MigrationVersion version = appliedMigration.getVersion();
        boolean outOfOrder1 = false;
        if (version != null) {
            if (version.compareTo(context.lastApplied) > 0) {
                context.lastApplied = version;
            } else {
                outOfOrder1 = true;
            }
        }
        if (appliedMigration.getType() == MigrationType.SCHEMA) {
            context.schema = version;
        }
        if (appliedMigration.getType() == MigrationType.BASELINE) {
            context.baseline = version;
        }
        if (version != null) {
            appliedMigrationsMap.put(version, Pair.of(appliedMigration, outOfOrder1));
        } else {
            appliedRepeatableMigrations.add(appliedMigration);
        }
    }
    if (MigrationVersion.CURRENT == target) {
        context.target = context.lastApplied;
    }
    Set<MigrationVersion> allVersions = new HashSet<MigrationVersion>();
    allVersions.addAll(resolvedMigrationsMap.keySet());
    allVersions.addAll(appliedMigrationsMap.keySet());
    List<MigrationInfoImpl> migrationInfos1 = new ArrayList<MigrationInfoImpl>();
    for (MigrationVersion version : allVersions) {
        ResolvedMigration resolvedMigration = resolvedMigrationsMap.get(version);
        Pair<AppliedMigration, Boolean> appliedMigrationInfo = appliedMigrationsMap.get(version);
        if (appliedMigrationInfo == null) {
            migrationInfos1.add(new MigrationInfoImpl(resolvedMigration, null, context, false));
        } else {
            migrationInfos1.add(new MigrationInfoImpl(resolvedMigration, appliedMigrationInfo.getLeft(), context, appliedMigrationInfo.getRight()));
        }
    }
    for (AppliedMigration appliedRepeatableMigration : appliedRepeatableMigrations) {
        if (!context.latestRepeatableRuns.containsKey(appliedRepeatableMigration.getDescription()) || (appliedRepeatableMigration.getInstalledRank() > context.latestRepeatableRuns.get(appliedRepeatableMigration.getDescription()))) {
            context.latestRepeatableRuns.put(appliedRepeatableMigration.getDescription(), appliedRepeatableMigration.getInstalledRank());
        }
    }
    Set<ResolvedMigration> pendingResolvedRepeatableMigrations = new HashSet<ResolvedMigration>(resolvedRepeatableMigrationsMap.values());
    for (AppliedMigration appliedRepeatableMigration : appliedRepeatableMigrations) {
        ResolvedMigration resolvedMigration = resolvedRepeatableMigrationsMap.get(appliedRepeatableMigration.getDescription());
        int latestRank = context.latestRepeatableRuns.get(appliedRepeatableMigration.getDescription());
        if (resolvedMigration != null && appliedRepeatableMigration.getInstalledRank() == latestRank && ObjectUtils.nullSafeEquals(appliedRepeatableMigration.getChecksum(), resolvedMigration.getChecksum())) {
            pendingResolvedRepeatableMigrations.remove(resolvedMigration);
        }
        migrationInfos1.add(new MigrationInfoImpl(resolvedMigration, appliedRepeatableMigration, context, false));
    }
    for (ResolvedMigration pendingResolvedRepeatableMigration : pendingResolvedRepeatableMigrations) {
        migrationInfos1.add(new MigrationInfoImpl(pendingResolvedRepeatableMigration, null, context, false));
    }
    Collections.sort(migrationInfos1);
    migrationInfos = migrationInfos1;
}

Example 19 with MigrationVersion

use of org.flywaydb.core.api.MigrationVersion in project flyway by flyway.

the class DbMigrate method applyMigration.

/**
     * Applies this migration to the database. The migration state and the execution time are updated accordingly.
     *
     * @param migration    The migration to apply.
     * @param isOutOfOrder If this migration is being applied out of order.
     * @return The result of the migration.
     */
private Boolean applyMigration(final MigrationInfoImpl migration, boolean isOutOfOrder) {
    MigrationVersion version = migration.getVersion();
    final MigrationExecutor migrationExecutor = migration.getResolvedMigration().getExecutor();
    final String migrationText;
    if (version != null) {
        migrationText = "schema " + schema + " to version " + version + " - " + migration.getDescription() + (isOutOfOrder ? " [out of order]" : "") + (migrationExecutor.executeInTransaction() ? "" : " [non-transactional]");
    } else {
        migrationText = "schema " + schema + " with repeatable migration " + migration.getDescription() + (migrationExecutor.executeInTransaction() ? "" : " [non-transactional]");
    }
    LOG.info("Migrating " + migrationText);
    StopWatch stopWatch = new StopWatch();
    stopWatch.start();
    try {
        if (migrationExecutor.executeInTransaction()) {
            new TransactionTemplate(connectionUserObjects).execute(new Callable<Object>() {

                @Override
                public Object call() throws SQLException {
                    doMigrate(migration, migrationExecutor, migrationText);
                    return null;
                }
            });
        } else {
            try {
                doMigrate(migration, migrationExecutor, migrationText);
            } catch (SQLException e) {
                throw new FlywaySqlException("Unable to apply migration", e);
            }
        }
    } catch (FlywayException e) {
        String failedMsg = "Migration of " + migrationText + " failed!";
        if (dbSupport.supportsDdlTransactions() && migrationExecutor.executeInTransaction()) {
            LOG.error(failedMsg + " Changes successfully rolled back.");
        } else {
            LOG.error(failedMsg + " Please restore backups and roll back database and code!");
            stopWatch.stop();
            int executionTime = (int) stopWatch.getTotalTimeMillis();
            AppliedMigration appliedMigration = new AppliedMigration(version, migration.getDescription(), migration.getType(), migration.getScript(), migration.getResolvedMigration().getChecksum(), executionTime, false);
            metaDataTable.addAppliedMigration(appliedMigration);
        }
        throw e;
    }
    stopWatch.stop();
    int executionTime = (int) stopWatch.getTotalTimeMillis();
    AppliedMigration appliedMigration = new AppliedMigration(version, migration.getDescription(), migration.getType(), migration.getScript(), migration.getResolvedMigration().getChecksum(), executionTime, true);
    metaDataTable.addAppliedMigration(appliedMigration);
    return false;
}

Example 20 with MigrationVersion

use of org.flywaydb.core.api.MigrationVersion in project che by eclipse.

the class CustomSqlMigrationResolver method resolveSqlMigrations.

private List<ResolvedMigration> resolveSqlMigrations() throws IOException, SQLException {
    LOG.info("Searching for sql scripts in locations {}", Arrays.toString(flywayConfiguration.getLocations()));
    final Map<Location, List<Resource>> allResources = finder.findResources(flywayConfiguration);
    LOG.debug("Found scripts: {}", allResources);
    final Map<String, Map<String, SqlScript>> scriptsInDir = new HashMap<>();
    for (Location location : allResources.keySet()) {
        final List<Resource> resources = allResources.get(location);
        for (Resource resource : resources) {
            final SqlScript newScript = scriptsCreator.createScript(location, resource);
            if (!scriptsInDir.containsKey(newScript.dir)) {
                scriptsInDir.put(newScript.dir, new HashMap<>(4));
            }
            final Map<String, SqlScript> existingScripts = scriptsInDir.get(newScript.dir);
            final SqlScript existingScript = existingScripts.get(newScript.name);
            if (existingScript == null) {
                existingScripts.put(newScript.name, newScript);
            } else if (Objects.equals(existingScript.vendor, newScript.vendor)) {
                throw new FlywayException(format("More than one script with name '%s' is registered for " + "database vendor '%s', script '%s' conflicts with '%s'", newScript.name, existingScript.vendor, newScript, existingScript));
            } else if (vendorName.equals(newScript.vendor)) {
                existingScripts.put(newScript.name, newScript);
            }
        }
    }
    final Map<MigrationVersion, ResolvedMigration> migrations = new HashMap<>();
    for (SqlScript script : scriptsInDir.values().stream().flatMap(scripts -> scripts.values().stream()).collect(toList())) {
        final ResolvedMigrationImpl migration = new ResolvedMigrationImpl();
        migration.setVersion(versionResolver.resolve(script, flywayConfiguration));
        migration.setScript(script.resource.getLocation());
        migration.setPhysicalLocation(script.resource.getLocationOnDisk());
        migration.setType(MigrationType.SQL);
        migration.setDescription(script.name);
        migration.setChecksum(ByteSource.wrap(script.resource.loadAsBytes()).hash(Hashing.crc32()).asInt());
        migration.setExecutor(new SqlMigrationExecutor(dbSupport, script.resource, placeholderReplacer, flywayConfiguration.getEncoding()));
        if (migrations.put(migration.getVersion(), migration) != null) {
            throw new FlywayException("Two migrations with the same version detected");
        }
    }
    return new ArrayList<>(migrations.values());
}