Java Examples for liquibase.changelog.DatabaseChangeLog

/**
     * This method will check the database ChangeLog table used to keep track of
     * the changes in the file. If the table does not exist it will create one
     * otherwise it will not do anything besides outputting a log message.
     * @param updateExistingNullChecksums
     * @param contexts
     */
public void checkDatabaseChangeLogTable(boolean updateExistingNullChecksums, DatabaseChangeLog databaseChangeLog, String... contexts) throws DatabaseException {
    Executor executor = ExecutorService.getInstance().getExecutor(this);
    Table changeLogTable = DatabaseSnapshotGeneratorFactory.getInstance().getGenerator(this).getDatabaseChangeLogTable(this);
    List<SqlStatement> statementsToExecute = new ArrayList<SqlStatement>();
    boolean changeLogCreateAttempted = false;
    if (changeLogTable != null) {
        boolean hasDescription = changeLogTable.getColumn("DESCRIPTION") != null;
        boolean hasComments = changeLogTable.getColumn("COMMENTS") != null;
        boolean hasTag = changeLogTable.getColumn("TAG") != null;
        boolean hasLiquibase = changeLogTable.getColumn("LIQUIBASE") != null;
        boolean liquibaseColumnNotRightSize = changeLogTable.getColumn("LIQUIBASE").getColumnSize() != 20;
        boolean hasOrderExecuted = changeLogTable.getColumn("ORDEREXECUTED") != null;
        boolean checksumNotRightSize = changeLogTable.getColumn("MD5SUM").getColumnSize() != 35;
        boolean hasExecTypeColumn = changeLogTable.getColumn("EXECTYPE") != null;
        if (!hasDescription) {
            executor.comment("Adding missing databasechangelog.description column");
            statementsToExecute.add(new AddColumnStatement(getLiquibaseSchemaName(), getDatabaseChangeLogTableName(), "DESCRIPTION", "VARCHAR(255)", null));
        }
        if (!hasTag) {
            executor.comment("Adding missing databasechangelog.tag column");
            statementsToExecute.add(new AddColumnStatement(getLiquibaseSchemaName(), getDatabaseChangeLogTableName(), "TAG", "VARCHAR(255)", null));
        }
        if (!hasComments) {
            executor.comment("Adding missing databasechangelog.comments column");
            statementsToExecute.add(new AddColumnStatement(getLiquibaseSchemaName(), getDatabaseChangeLogTableName(), "COMMENTS", "VARCHAR(255)", null));
        }
        if (!hasLiquibase) {
            executor.comment("Adding missing databasechangelog.liquibase column");
            statementsToExecute.add(new AddColumnStatement(getLiquibaseSchemaName(), getDatabaseChangeLogTableName(), "LIQUIBASE", "VARCHAR(255)", null));
        }
        if (!hasOrderExecuted) {
            executor.comment("Adding missing databasechangelog.orderexecuted column");
            statementsToExecute.add(new AddColumnStatement(getLiquibaseSchemaName(), getDatabaseChangeLogTableName(), "ORDEREXECUTED", "INT", null));
            statementsToExecute.add(new UpdateStatement(getLiquibaseSchemaName(), getDatabaseChangeLogTableName()).addNewColumnValue("ORDEREXECUTED", -1));
            statementsToExecute.add(new SetNullableStatement(getLiquibaseSchemaName(), getDatabaseChangeLogTableName(), "ORDEREXECUTED", "INT", false));
        }
        if (checksumNotRightSize) {
            executor.comment("Modifying size of databasechangelog.md5sum column");
            statementsToExecute.add(new ModifyDataTypeStatement(getLiquibaseSchemaName(), getDatabaseChangeLogTableName(), "MD5SUM", "VARCHAR(35)"));
        }
        if (liquibaseColumnNotRightSize) {
            executor.comment("Modifying size of databasechangelog.liquibase column");
            statementsToExecute.add(new ModifyDataTypeStatement(getLiquibaseSchemaName(), getDatabaseChangeLogTableName(), "LIQUIBASE", "VARCHAR(20)"));
        }
        if (!hasExecTypeColumn) {
            executor.comment("Adding missing databasechangelog.exectype column");
            statementsToExecute.add(new AddColumnStatement(getLiquibaseSchemaName(), getDatabaseChangeLogTableName(), "EXECTYPE", "VARCHAR(10)", null));
            statementsToExecute.add(new UpdateStatement(getLiquibaseSchemaName(), getDatabaseChangeLogTableName()).addNewColumnValue("EXECTYPE", "EXECUTED"));
            statementsToExecute.add(new SetNullableStatement(getLiquibaseSchemaName(), getDatabaseChangeLogTableName(), "EXECTYPE", "VARCHAR(10)", false));
        }
        List<Map> md5sumRS = ExecutorService.getInstance().getExecutor(this).queryForList(new SelectFromDatabaseChangeLogStatement(new SelectFromDatabaseChangeLogStatement.ByNotNullCheckSum(), "MD5SUM"));
        if (md5sumRS.size() > 0) {
            String md5sum = md5sumRS.get(0).get("MD5SUM").toString();
            if (!md5sum.startsWith(CheckSum.getCurrentVersion() + ":")) {
                executor.comment("DatabaseChangeLog checksums are an incompatible version.  Setting them to null so they will be updated on next database update");
                statementsToExecute.add(new RawSqlStatement("UPDATE " + escapeTableName(getLiquibaseSchemaName(), getDatabaseChangeLogTableName()) + " SET MD5SUM=null"));
            }
        }
    } else if (!changeLogCreateAttempted) {
        executor.comment("Create Database Change Log Table");
        SqlStatement createTableStatement = new CreateDatabaseChangeLogTableStatement();
        if (!canCreateChangeLogTable()) {
            throw new DatabaseException("Cannot create " + escapeTableName(getDefaultSchemaName(), getDatabaseChangeLogTableName()) + " table for your database.\n\n" + "Please construct it manually using the following SQL as a base and re-run Liquibase:\n\n" + createTableStatement);
        }
        // If there is no table in the database for recording change history create one.
        statementsToExecute.add(createTableStatement);
        LogFactory.getLogger().info("Creating database history table with name: " + escapeTableName(getDefaultSchemaName(), getDatabaseChangeLogTableName()));
    //                }
    }
    for (SqlStatement sql : statementsToExecute) {
        executor.execute(sql);
        this.commit();
    }
    if (updateExistingNullChecksums) {
        for (RanChangeSet ranChangeSet : this.getRanChangeSetList()) {
            if (ranChangeSet.getLastCheckSum() == null) {
                ChangeSet changeSet = databaseChangeLog.getChangeSet(ranChangeSet);
                if (changeSet != null && new ContextChangeSetFilter(contexts).accepts(changeSet) && new DbmsChangeSetFilter(this).accepts(changeSet)) {
                    LogFactory.getLogger().info("Updating null or out of date checksum on changeSet " + changeSet + " to correct value");
                    executor.execute(new UpdateChangeSetChecksumStatement(changeSet));
                }
            }
        }
        commit();
        this.ranChangeSetList = null;
    }
}

//    private TestLiquibase testLiquibase;
//    private DatabaseConnection connectionForConstructor;
@Before
public void before() throws Exception {
    //        if (connectionForConstructor != null) {
    //            reset(connectionForConstructor);
    //        }
    //        connectionForConstructor = createMock(DatabaseConnection.class);
    //        connectionForConstructor.setAutoCommit(false);
    //        expectLastCall().atLeastOnce();
    //
    //        DatabaseMetaData metaData = createMock(DatabaseMetaData.class);
    //        expect(metaData.getDatabaseProductName()).andReturn("Oracle");
    //        replay(metaData);
    //
    ////        expect(connectionForConstructor.getMetaData()).andReturn(metaData);
    //        replay(connectionForConstructor);
    //
    //        testLiquibase = new TestLiquibase();
    mockResourceAccessor = new MockResourceAccessor();
    mockDatabase = mock(Database.class);
    mockLockService = mock(LockService.class);
    mockLockServiceFactory = mock(LockServiceFactory.class);
    mockChangeLogParserFactory = mock(ChangeLogParserFactory.class);
    mockChangeLogParser = mock(ChangeLogParser.class);
    mockChangeLog = mock(DatabaseChangeLog.class);
    mockChangeLogIterator = mock(ChangeLogIterator.class);
    mockLogger = mock(Logger.class);
    LockServiceFactory.setInstance(mockLockServiceFactory);
    when(mockLockServiceFactory.getLockService(any(Database.class))).thenReturn(mockLockService);
    ChangeLogParserFactory.setInstance(mockChangeLogParserFactory);
    when(mockChangeLogParserFactory.getParser(anyString(), Mockito.isA(ResourceAccessor.class))).thenReturn(mockChangeLogParser);
    when(mockChangeLogParser.parse(anyString(), any(ChangeLogParameters.class), Mockito.isA(ResourceAccessor.class))).thenReturn(mockChangeLog);
    LogFactory.setInstance(new LogFactory() {

        @Override
        public Logger getLog(String name) {
            return mockLogger;
        }
    });
}

public void check(Database database, DatabaseChangeLog changeLog, ChangeSet changeSet) throws PreconditionFailedException, PreconditionErrorException {
    JdbcConnection connection = (JdbcConnection) database.getConnection();
    PreparedStatement ps = null;
    ResultSet rs = null;
    try {
        if (getIndexName() != null) {
            final String sql = "select count(*) from all_indexes i join dual d on upper(i.index_name) = upper(?) and upper(i.owner) = upper(?) left join all_constraints c on i.index_name = c.constraint_name where c.constraint_name is null";
            ps = connection.prepareStatement(sql);
            ps.setString(1, getIndexName());
            ps.setString(2, database.getLiquibaseSchemaName());
            rs = ps.executeQuery();
            if (!rs.next() || rs.getInt(1) <= 0) {
                throw new PreconditionFailedException(String.format("The index '%s.%s' was not found.", database.getLiquibaseSchemaName(), getIndexName()), changeLog, this);
            }
        } else {
            final String sql = "select i.index_name, i.column_name from ( select * from all_ind_columns where upper(table_name) = upper (?) and upper(index_owner) = upper(?) ) i left join all_constraints c on i.index_name = c.constraint_name where c.constraint_name is null";
            ps = connection.prepareStatement(sql);
            ps.setString(1, getTableName());
            ps.setString(2, database.getLiquibaseSchemaName());
            rs = ps.executeQuery();
            Map<String, List<String>> columnsMap = new HashMap<String, List<String>>();
            while (rs.next()) {
                String indexName = rs.getString(1);
                String columnName = rs.getString(2);
                List<String> cols = columnsMap.get(indexName);
                if (cols == null) {
                    cols = new ArrayList<String>();
                    columnsMap.put(indexName, cols);
                }
                cols.add(columnName.toUpperCase());
            }
            String[] expectedColumns = getColumnNames().toUpperCase().split("\\s*,\\s*");
            // check for an index with all columns listed.
            for (String index : columnsMap.keySet()) {
                List<String> columnNames = columnsMap.get(index);
                if (columnNames.size() == expectedColumns.length) {
                    if (columnNames.containsAll(Arrays.asList(expectedColumns))) {
                        return;
                    }
                }
            }
            throw new PreconditionFailedException(String.format("No index was found on table '%s.%s' with columns '%s'.", database.getLiquibaseSchemaName(), getTableName(), getColumnNames()), changeLog, this);
        }
    } catch (SQLException e) {
        throw new PreconditionErrorException(e, changeLog, this);
    } catch (DatabaseException e) {
        throw new PreconditionErrorException(e, changeLog, this);
    } finally {
        closeSilently(rs);
        closeSilently(ps);
    }
}

private DatabaseChangeLog getChangeLog() {
    if (changeLog == null) {
        try {
            ChangeLogParameters params = new ChangeLogParameters();
            changeLog = new XMLChangeLogSAXParser().parse(getChangeLogFile(), params, new FileSystemResourceAccessor());
        } catch (Exception ex) {
            logger.log(Level.SEVERE, null, ex);
        }
    }
    return changeLog;
}

@Test
public void parseAndGenerate() throws Exception {
    if (connection == null) {
        return;
    }
    Database database = liquiBase.getDatabase();
    ResourceAccessor resourceAccessor = new ClassLoaderResourceAccessor();
    ChangeLogParameters changeLogParameters = new ChangeLogParameters();
    DatabaseChangeLog changeLog = ChangeLogParserFactory.getInstance().getParser(changeLogFile, resourceAccessor).parse(changeLogFile, changeLogParameters, resourceAccessor);
    changeLog.validate(database);
    List<ChangeSet> changeSets = changeLog.getChangeSets();
    List<String> expectedQuery = new ArrayList<String>();
    expectedQuery.add("CREATE TABLE LBUSER.person (id NUMBER(10), name VARCHAR2(50))");
    expectedQuery.add("INSERT INTO LBUSER.person (id, name) VALUES ('1', 'James')");
    expectedQuery.add("ALTER TABLE LBUSER.person RENAME TO Tperson");
    expectedQuery.add("CREATE OR REPLACE VIEW LBUSER.person AS SELECT * FROM Tperson");
    int i = 0;
    for (ChangeSet changeSet : changeSets) {
        for (Change change : changeSet.getChanges()) {
            Sql[] sql = SqlGeneratorFactory.getInstance().generateSql(change.generateStatements(database)[0], database);
            assertEquals(expectedQuery.get(i), sql[0].toSql());
        }
        i++;
    }
}

/*
	 * (non-Javadoc)
	 * 
	 * @see liquibase.Liquibase#update(java.lang.String)
	 */
@Override
public void update(String contexts) throws LiquibaseException {
    contexts = StringUtils.trimToNull(contexts);
    LockServiceEx lockService = LockServiceEx.getInstance(database);
    lockService.waitForLock();
    try {
        getChangeLogParameters().setContexts(StringUtils.splitAndTrim(contexts, ","));
        DatabaseChangeLog changeLog = ChangeLogParserFactory.getInstance().getParser(this.changeLogFile, getFileOpener()).parse(this.changeLogFile, getChangeLogParameters(), getFileOpener());
        checkDatabaseChangeLogTable(true, changeLog, contexts);
        changeLog.validate(database, contexts);
        ChangeLogIterator changeLogIterator = getStandardChangelogIterator(contexts, changeLog);
        changeLogIterator.run(new UpdateVisitor(database), database);
    } finally {
        try {
            lockService.releaseLock();
        } catch (LockException e) {
            LOGGER.error("Error while releasing db lock", e);
        }
    }
}

@Test
public void testReadLiquibaseUsePerconaFlagYAML() throws Exception {
    DatabaseChangeLog changelog = loadChangeLog("test-changelog.yaml");
    Assert.assertEquals(2, changelog.getChangeSets().size());
    ChangeSet addColumnChangeset = changelog.getChangeSets().get(1);
    Change change = addColumnChangeset.getChanges().get(0);
    Assert.assertEquals(PerconaAddColumnChange.class, change.getClass());
    Assert.assertNotNull(((PerconaAddColumnChange) change).getUsePercona());
    Assert.assertFalse(((PerconaAddColumnChange) change).getUsePercona());
}

@Override
public void check(final Database database, final DatabaseChangeLog changeLog, final ChangeSet changeSet) throws PreconditionFailedException, PreconditionErrorException {
    Precondition delegatedPrecondition;
    if (database instanceof DerbyDatabase || database instanceof H2Database) {
        final TableExistsPrecondition precondition = new TableExistsPrecondition();
        precondition.setCatalogName(getCatalogName());
        precondition.setSchemaName(getSchemaName());
        final String tableName = getHatboxTableName();
        precondition.setTableName(tableName);
        delegatedPrecondition = precondition;
    } else {
        final IndexExistsPrecondition precondition = new IndexExistsPrecondition();
        precondition.setCatalogName(getCatalogName());
        precondition.setSchemaName(getSchemaName());
        precondition.setTableName(getTableName());
        precondition.setIndexName(getIndexName());
        precondition.setColumnNames(getColumnNames());
        delegatedPrecondition = precondition;
    }
    delegatedPrecondition.check(database, changeLog, changeSet);
}

/**
	 * This code was borrowed from the liquibase jar so that we can call the given callback
	 * function.
	 *
	 * @param changeLogFile the file to execute
	 * @param contexts the liquibase changeset context
	 * @param userInput answers given by the user
	 * @param callback the function to call after every changeset
	 * @param cl {@link ClassLoader} to use to find the changeLogFile (or null to use
	 *            {@link OpenmrsClassLoader})
	 * @return A list of messages or warnings generated by the executed changesets
	 * @throws Exception
	 */
public static List<String> executeChangelog(String changeLogFile, String contexts, Map<String, Object> userInput, ChangeSetExecutorCallback callback, ClassLoader cl) throws Exception {
    final class OpenmrsUpdateVisitor extends UpdateVisitor {

        private ChangeSetExecutorCallback callback;

        private int numChangeSetsToRun;

        public OpenmrsUpdateVisitor(Database database, ChangeSetExecutorCallback callback, int numChangeSetsToRun) {
            super(database);
            this.callback = callback;
            this.numChangeSetsToRun = numChangeSetsToRun;
        }

        @Override
        public void visit(ChangeSet changeSet, DatabaseChangeLog databaseChangeLog, Database database) throws LiquibaseException {
            if (callback != null) {
                callback.executing(changeSet, numChangeSetsToRun);
            }
            super.visit(changeSet, databaseChangeLog, database);
        }
    }
    if (cl == null) {
        cl = OpenmrsClassLoader.getInstance();
    }
    log.debug("Setting up liquibase object to run changelog: " + changeLogFile);
    Liquibase liquibase = getLiquibase(changeLogFile, cl);
    int numChangeSetsToRun = liquibase.listUnrunChangeSets(contexts).size();
    Database database = null;
    LockService lockHandler = null;
    try {
        database = liquibase.getDatabase();
        lockHandler = LockService.getInstance(database);
        lockHandler.waitForLock();
        ResourceAccessor openmrsFO = new ClassLoaderFileOpener(cl);
        ResourceAccessor fsFO = new FileSystemResourceAccessor();
        DatabaseChangeLog changeLog = new XMLChangeLogSAXParser().parse(changeLogFile, new ChangeLogParameters(), new CompositeResourceAccessor(openmrsFO, fsFO));
        changeLog.setChangeLogParameters(liquibase.getChangeLogParameters());
        changeLog.validate(database);
        ChangeLogIterator logIterator = new ChangeLogIterator(changeLog, new ShouldRunChangeSetFilter(database), new ContextChangeSetFilter(contexts), new DbmsChangeSetFilter(database));
        database.checkDatabaseChangeLogTable(true, changeLog, new String[] { contexts });
        logIterator.run(new OpenmrsUpdateVisitor(database, callback, numChangeSetsToRun), database);
    } catch (LiquibaseException e) {
        throw e;
    } finally {
        try {
            lockHandler.releaseLock();
        } catch (Exception e) {
            log.error("Could not release lock", e);
        }
        try {
            database.getConnection().close();
        } catch (Exception e) {
        }
    }
    return updateWarnings;
}

public String serialize(DatabaseChangeLog databaseChangeLog) {
    return null;
}

@Override
public void setChangeLog(DatabaseChangeLog databaseChangeLog) {
    changeLogName = (databaseChangeLog == null) ? null : databaseChangeLog.getFilePath();
}

@Override
public void setChangeLog(DatabaseChangeLog databaseChangeLog) {
}

@Override
public void setChangeLog(DatabaseChangeLog databaseChangeLog) {
}