import liquibase.executor.Executor; //导入依赖的package包/类
@Override
    public void tag(final String tagString) throws DatabaseException {
        Database database = getDatabase();
        Executor executor = ExecutorService.getInstance().getExecutor(database);
        try {
            int totalRows = ExecutorService.getInstance().getExecutor(database).queryForInt(new SelectFromDatabaseChangeLogStatement(new ColumnConfig().setName("COUNT(*)", true)));
            if (totalRows == 0) {
                ChangeSet emptyChangeSet = new ChangeSet(String.valueOf(new Date().getTime()), "liquibase", false, false, "liquibase-internal", null, null, getDatabase().getObjectQuotingStrategy(), null);
                this.setExecType(emptyChangeSet, ChangeSet.ExecType.EXECUTED);
            }

//            Timestamp lastExecutedDate = (Timestamp) this.getExecutor().queryForObject(createChangeToTagSQL(), Timestamp.class);
            executor.execute(new TagDatabaseStatement(tagString));
            getDatabase().commit();

            if (this.ranChangeSetList != null) {
                ranChangeSetList.get(ranChangeSetList.size() - 1).setTag(tagString);
            }
        } catch (Exception e) {
            throw new DatabaseException(e);
        }
    }
 

import liquibase.executor.Executor; //导入依赖的package包/类
@Override
public SqlStatement[] generateStatements(final Database database)
{
	validateParameters();

	final Executor currentExecutor = ExecutorService.getInstance().getExecutor(database);

	if (startOrStop == START_OR_STOP.START)
	{
		startSuppressing(database, currentExecutor);
	}
	else if (startOrStop == START_OR_STOP.STOP)
	{
		stopSuppressing(database, currentExecutor);
	}
	else
	{
		throw new IllegalArgumentException("Unknown startOrStop value " + startOrStop.name());
	}

	return new SqlStatement[] {};
}
 

import liquibase.executor.Executor; //导入依赖的package包/类
@Override
public SqlStatement[] generateRollbackStatements(final Database database) throws RollbackImpossibleException
{
	validateParameters();

	final Executor currentExecutor = ExecutorService.getInstance().getExecutor(database);

	if (startOrStop == START_OR_STOP.START)
	{
		stopSuppressing(database, currentExecutor);
	}
	else if (startOrStop == START_OR_STOP.STOP)
	{
		startSuppressing(database, currentExecutor);
	}
	else
	{
		throw new IllegalArgumentException("Unknown startOrStop value " + startOrStop.name());
	}

	return new SqlStatement[] {};
}
 

import liquibase.executor.Executor; //导入依赖的package包/类
/**
     * Tags the database changelog with the given string.
     */
    public void tag(String tagString) throws DatabaseException {
        Executor executor = ExecutorService.getInstance().getExecutor(this);
        try {
            int totalRows = ExecutorService.getInstance().getExecutor(this).queryForInt(new SelectFromDatabaseChangeLogStatement("COUNT(*)"));
            if (totalRows == 0) {
                ChangeSet emptyChangeSet = new ChangeSet(String.valueOf(new Date().getTime()), "liquibase", false, false, "liquibase-internal", null, null);
                this.markChangeSetExecStatus(emptyChangeSet, ChangeSet.ExecType.EXECUTED);
            }

//            Timestamp lastExecutedDate = (Timestamp) this.getExecutor().queryForObject(createChangeToTagSQL(), Timestamp.class);
            executor.execute(new TagDatabaseStatement(tagString));
            this.commit();

            getRanChangeSetList().get(getRanChangeSetList().size() - 1).setTag(tagString);
        } catch (Exception e) {
            throw new DatabaseException(e);
        }
    }
 

import liquibase.executor.Executor; //导入依赖的package包/类
public void update(String contexts, Writer output) throws LiquibaseException {
    contexts = StringUtils.trimToNull(contexts);
    changeLogParameters.setContexts(StringUtils.splitAndTrim(contexts, ","));

    Executor oldTemplate = ExecutorService.getInstance().getExecutor(database);
    LoggingExecutor loggingExecutor = new LoggingExecutor(ExecutorService.getInstance().getExecutor(database), output, database);
    ExecutorService.getInstance().setExecutor(database, loggingExecutor);

    outputHeader("Update Database Script");

    LockService lockService = LockService.getInstance(database);
    lockService.waitForLock();

    try {

        update(contexts);

        output.flush();
    } catch (IOException e) {
        throw new LiquibaseException(e);
    } finally {
        lockService.releaseLock();
    }

    ExecutorService.getInstance().setExecutor(database, oldTemplate);
}
 

import liquibase.executor.Executor; //导入依赖的package包/类
public void rollback(int changesToRollback, String contexts, Writer output) throws LiquibaseException {
    contexts = StringUtils.trimToNull(contexts);
    changeLogParameters.setContexts(StringUtils.splitAndTrim(contexts, ","));

    Executor oldTemplate = ExecutorService.getInstance().getExecutor(database);
    ExecutorService.getInstance().setExecutor(database, new LoggingExecutor(ExecutorService.getInstance().getExecutor(database), output, database));

    outputHeader("Rollback " + changesToRollback + " Change(s) Script");

    rollback(changesToRollback, contexts);

    try {
        output.flush();
    } catch (IOException e) {
        throw new LiquibaseException(e);
    }
    ExecutorService.getInstance().setExecutor(database, oldTemplate);
}
 

import liquibase.executor.Executor; //导入依赖的package包/类
public void changeLogSync(String contexts, Writer output) throws LiquibaseException {
    contexts = StringUtils.trimToNull(contexts);
    changeLogParameters.setContexts(StringUtils.splitAndTrim(contexts, ","));

    LoggingExecutor outputTemplate = new LoggingExecutor(ExecutorService.getInstance().getExecutor(database), output, database);
    Executor oldTemplate = ExecutorService.getInstance().getExecutor(database);
    ExecutorService.getInstance().setExecutor(database, outputTemplate);

    outputHeader("SQL to add all changesets to database history table");

    changeLogSync(contexts);

    try {
        output.flush();
    } catch (IOException e) {
        throw new LiquibaseException(e);
    }

    ExecutorService.getInstance().setExecutor(database, oldTemplate);
}
 

import liquibase.executor.Executor; //导入依赖的package包/类
public void markNextChangeSetRan(String contexts, Writer output) throws LiquibaseException {
    contexts = StringUtils.trimToNull(contexts);
    changeLogParameters.setContexts(StringUtils.splitAndTrim(contexts, ","));


    LoggingExecutor outputTemplate = new LoggingExecutor(ExecutorService.getInstance().getExecutor(database), output, database);
    Executor oldTemplate = ExecutorService.getInstance().getExecutor(database);
    ExecutorService.getInstance().setExecutor(database, outputTemplate);

    outputHeader("SQL to add all changesets to database history table");

    markNextChangeSetRan(contexts);

    try {
        output.flush();
    } catch (IOException e) {
        throw new LiquibaseException(e);
    }

    ExecutorService.getInstance().setExecutor(database, oldTemplate);
}
 

import liquibase.executor.Executor; //导入依赖的package包/类
/**
 * Determines whether *SQL (updateSQL/rollbackSQL) is executed or whether
 * the statements should be executed directly.
 * @param database the database
 * @return <code>true</code> if dry-run is enabled and the statements should *not* be executed.
 */
private static boolean isDryRun(Database database) {
    Executor executor = ExecutorService.getInstance().getExecutor(database);
    if (executor instanceof LoggingExecutor) {
        return true;
    }
    return false;
}
 

import liquibase.executor.Executor; //导入依赖的package包/类
public static void cleanDB() throws Exception {
	liquiBase = new Liquibase( changeLogFile, new ClassLoaderResourceAccessor(), jdbcConnection );
	liquiBase.dropAll();
	
	Executor executor = ExecutorService.getInstance().getExecutor( liquiBase.getDatabase() );
	ResultSet rs = null;
	try {
		rs = jdbcConnection.getMetaData().getTables( null, liquiBase.getDatabase().getDefaultSchemaName(), "%", new String[] { "MATERIALIZED VIEW" } );
		while ( rs.next() ) {
			executor.execute( new DropMaterializedViewStatement( rs.getString( "TABLE_NAME" ) ) );
		}
	} finally {
		closeSilently( rs );
	}
}
 

import liquibase.executor.Executor; //导入依赖的package包/类
@Override
protected void writeBody(FileWriter fileWriter, Object object, List<Change> ranChanges, List<Change> changesToRun) throws IOException, DatabaseHistoryException, DatabaseException {

    Executor oldTemplate = ExecutorService.getInstance().getExecutor(database);
    LoggingExecutor loggingExecutor = new LoggingExecutor(ExecutorService.getInstance().getExecutor(database), fileWriter, database);
    ExecutorService.getInstance().setExecutor(database, loggingExecutor);

    try {
        if (changesToRun.size() == 0) {
            fileWriter.append("<b>NONE</b>");
        }

        fileWriter.append("<code><pre>");

        ChangeSet lastRunChangeSet = null;

        for (Change change : changesToRun) {
            ChangeSet thisChangeSet = change.getChangeSet();
            if (thisChangeSet.equals(lastRunChangeSet)) {
                continue;
            }
            lastRunChangeSet = thisChangeSet;
            String anchor = thisChangeSet.toString(false).replaceAll("\\W","_");
            fileWriter.append("<a name='").append(anchor).append("'/>");
            try {
                thisChangeSet.execute(databaseChangeLog, this.database);
            } catch (MigrationFailedException e) {
                fileWriter.append("EXECUTION ERROR: ").append(change.getChangeMetaData().getDescription()).append(": ").append(e.getMessage()).append("\n\n");
            }
        }
        fileWriter.append("</pre></code>");
    } finally {
        ExecutorService.getInstance().setExecutor(database, oldTemplate);
    }
}
 

import liquibase.executor.Executor; //导入依赖的package包/类
/**
 * This method will check the database ChangeLogLock table used to keep track of
 * if a machine is updating the database. If the table does not exist it will create one
 * otherwise it will not do anything besides outputting a log message.
 */
public void checkDatabaseChangeLogLockTable() throws DatabaseException {

    Executor executor = ExecutorService.getInstance().getExecutor(this);
    if (!hasDatabaseChangeLogLockTable()) {

        executor.comment("Create Database Lock Table");
        executor.execute(new CreateDatabaseChangeLogLockTableStatement());
        this.commit();
        LogFactory.getLogger().debug("Created database lock table with name: " + escapeTableName(getLiquibaseSchemaName(), getDatabaseChangeLogLockTableName()));
        this.hasDatabaseChangeLogLockTable = true;
    }
}
 

import liquibase.executor.Executor; //导入依赖的package包/类
@Override
public String getViewDefinition(String schemaName, String viewName) throws DatabaseException {
       GetViewDefinitionStatement statement = new GetViewDefinitionStatement(convertRequestedSchemaToSchema(schemaName), viewName);
       Executor executor = ExecutorService.getInstance().getExecutor(this);
       @SuppressWarnings("unchecked")
       List<String> definitionRows = (List<String>) executor.queryForList(statement, String.class);
       StringBuilder definition = new StringBuilder();
       for (String d : definitionRows) {
       	definition.append(d);
       }
       return definition.toString();
}
 

import liquibase.executor.Executor; //导入依赖的package包/类
private void outputHeader(String message) throws DatabaseException {
    Executor executor = ExecutorService.getInstance().getExecutor(database);
    executor.comment("*********************************************************************");
    executor.comment(message);
    executor.comment("*********************************************************************");
    executor.comment("Change Log: " + changeLogFile);
    executor.comment("Ran at: " + DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT).format(new Date()));
    executor.comment("Against: " + getDatabase().getConnection().getConnectionUserName() + "@" + getDatabase().getConnection().getURL());
    executor.comment("Liquibase version: " + LiquibaseUtil.getBuildVersion());
    executor.comment("*********************************************************************" + StreamUtil.getLineSeparator());
}
 

import liquibase.executor.Executor; //导入依赖的package包/类
@Test
public void test() throws Exception {
	final List<String> expected = Arrays.asList( 
			"iftableexists", "iftablenotexists", "ifviewexists", "ifviewnotexists", 
			"ifindexexists1", "ifindexexists2", "ifindexnotexists1", "ifpkexists",
			"ifpknotexists", "iffkexists", "iffknotexists", "ifsequenceexists",
			"ifsequencenotexists"
	);
	Executor executor = ExecutorService.getInstance().getExecutor( liquiBase.getDatabase() );
	List<String> successes = executor.queryForList( new RawSqlStatement( "select * from testresults" ), String.class );
	assertTrue( successes.containsAll( expected ) );
}
 

import liquibase.executor.Executor; //导入依赖的package包/类
public SuppressOutputExecutor(final Executor previousExecutor, final Database database)
{
	this.previousExecutor = previousExecutor;
	setDatabase(database);
}
 

import liquibase.executor.Executor; //导入依赖的package包/类
public Executor getPreviousExecutor()
{
	return previousExecutor;
}
 

import liquibase.executor.Executor; //导入依赖的package包/类
public void futureRollbackSQL(Integer count, String contexts, Writer output) throws LiquibaseException {
    contexts = StringUtils.trimToNull(contexts);
    changeLogParameters.setContexts(StringUtils.splitAndTrim(contexts, ","));

    LoggingExecutor outputTemplate = new LoggingExecutor(ExecutorService.getInstance().getExecutor(database), output, database);
    Executor oldTemplate = ExecutorService.getInstance().getExecutor(database);
    ExecutorService.getInstance().setExecutor(database, outputTemplate);

    outputHeader("SQL to roll back currently unexecuted changes");

    LockService lockService = LockService.getInstance(database);
    lockService.waitForLock();

    try {
        DatabaseChangeLog changeLog = ChangeLogParserFactory.getInstance().getParser(changeLogFile, resourceAccessor).parse(changeLogFile, changeLogParameters, resourceAccessor);
        checkDatabaseChangeLogTable(false, changeLog, contexts);
        changeLog.validate(database, contexts);

        ChangeLogIterator logIterator;
        if (count == null) {
            logIterator = new ChangeLogIterator(changeLog,
                    new NotRanChangeSetFilter(database.getRanChangeSetList()),
                    new ContextChangeSetFilter(contexts),
                    new DbmsChangeSetFilter(database));
        } else {
            ChangeLogIterator forwardIterator = new ChangeLogIterator(changeLog,
                    new NotRanChangeSetFilter(database.getRanChangeSetList()),
                    new ContextChangeSetFilter(contexts),
                    new DbmsChangeSetFilter(database),
                    new CountChangeSetFilter(count));
            final ListVisitor listVisitor = new ListVisitor();
            forwardIterator.run(listVisitor, database);

            logIterator = new ChangeLogIterator(changeLog,
                    new NotRanChangeSetFilter(database.getRanChangeSetList()),
                    new ContextChangeSetFilter(contexts),
                    new DbmsChangeSetFilter(database),
                    new ChangeSetFilter() {
                        public boolean accepts(ChangeSet changeSet) {
                            return listVisitor.getSeenChangeSets().contains(changeSet);
                        }
                    });
        }

        logIterator.run(new RollbackVisitor(database), database);
    } finally {
        lockService.releaseLock();
        ExecutorService.getInstance().setExecutor(database, oldTemplate);
    }

    try {
        output.flush();
    } catch (IOException e) {
        throw new LiquibaseException(e);
    }

}
 

import liquibase.executor.Executor; //导入依赖的package包/类
private void generateChildren(Database database) {
    // Make a new list
    childDropChanges = new ArrayList<DropForeignKeyConstraintChange>();

    Executor executor = ExecutorService.getInstance().getExecutor(database);

    FindForeignKeyConstraintsStatement sql = new FindForeignKeyConstraintsStatement(
            getBaseTableSchemaName(),
            getBaseTableName()
    );

    try {
        List<Map> results = executor.queryForList(sql);
        Set<String> handledConstraints = new HashSet<String>();

        if (results != null && results.size() > 0) {
            for (Map result : results) {
                String baseTableName =
                        (String) result.get(FindForeignKeyConstraintsStatement.RESULT_COLUMN_BASE_TABLE_NAME);
                String constraintName =
                        (String) result.get(FindForeignKeyConstraintsStatement.RESULT_COLUMN_CONSTRAINT_NAME);
                if (getBaseTableName().equalsIgnoreCase(baseTableName)) {
                    if( !handledConstraints.contains(constraintName)) {
                        DropForeignKeyConstraintChange dropForeignKeyConstraintChange =
                                new DropForeignKeyConstraintChange();

                        dropForeignKeyConstraintChange.setBaseTableSchemaName(getBaseTableSchemaName());
                        dropForeignKeyConstraintChange.setBaseTableName(baseTableName);
                        dropForeignKeyConstraintChange.setConstraintName(constraintName);

                        childDropChanges.add(dropForeignKeyConstraintChange);
                        handledConstraints.add(constraintName);
                    }
                } else {
                    throw new IllegalStateException("Expected to return only foreign keys for base table name: " +
                            getBaseTableName() + " and got results for table: " + baseTableName);
                }
            }
        }
    } catch (DatabaseException e) {
        throw new UnexpectedLiquibaseException("Failed to find foreign keys for table: " + getBaseTableName(), e);
    }
}