import liquibase.executor.ExecutorService; //导入依赖的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.ExecutorService; //导入依赖的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.ExecutorService; //导入依赖的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.ExecutorService; //导入依赖的package包/类
@Override
public void close() throws DatabaseException {

    // copy-paste from AbstractJdbcDatabase plus reflection to deal with private fields...

    ExecutorService.getInstance().clearExecutor(this);
    DatabaseConnection connection = getConnection();
    if (connection != null) {

        Boolean previousAutoCommit = previousAutoCommit();
        if (previousAutoCommit != null) {
            try {
                connection.setAutoCommit(previousAutoCommit);
            } catch (DatabaseException e) {
                LogFactory.getInstance().getLog().warning("Failed to restore the auto commit to " + previousAutoCommit);
                throw e;
            }
        }
        connection.close();
    }
}
 

import liquibase.executor.ExecutorService; //导入依赖的package包/类
@Before
public void setup() {
    System.setProperty(Configuration.LIQUIBASE_PASSWORD, "root");

    database = new MySQLDatabase();
    database.setLiquibaseSchemaName("testdb");
    DatabaseConnection conn = new MockDatabaseConnection("jdbc:mysql://[email protected]:3306/testdb",
            "[email protected]");
    database.setConnection(conn);
    ExecutorService.getInstance().setExecutor(database, new JdbcExecutor());

    PTOnlineSchemaChangeStatement.available = true;
    PTOnlineSchemaChangeStatement.perconaToolkitVersion = null;
    System.setProperty(Configuration.FAIL_IF_NO_PT, "false");
    System.setProperty(Configuration.NO_ALTER_SQL_DRY_MODE, "false");
    System.setProperty(Configuration.SKIP_CHANGES, "");

    setupChange(change);
}
 

import liquibase.executor.ExecutorService; //导入依赖的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.ExecutorService; //导入依赖的package包/类
@Override
public String getViewDefinition(String schemaName, String viewName) throws DatabaseException {
    if (schemaName == null) {
        schemaName = convertRequestedSchemaToSchema(null);
    }
    List<String> defLines = (List<String>) ExecutorService.getInstance().getExecutor(this).queryForList(new GetViewDefinitionStatement(schemaName, viewName), String.class);
    StringBuffer sb = new StringBuffer();
    for (String defLine : defLines) {
        sb.append(defLine);
    }
    String definition = sb.toString();

    if (definition == null) {
        return null;
    }
    return CREATE_VIEW_AS_PATTERN.matcher(definition).replaceFirst("");
}
 

import liquibase.executor.ExecutorService; //导入依赖的package包/类
public void check(Database database, DatabaseChangeLog changeLog, ChangeSet changeSet) throws PreconditionFailedException, PreconditionErrorException {
    DatabaseConnection connection = database.getConnection();
    try {
        String result = (String) ExecutorService.getInstance().getExecutor(database).queryForObject(new RawSqlStatement(getSql().replaceFirst(";$","")), String.class);
        if (result == null) {
            throw new PreconditionFailedException("No rows returned from SQL Precondition", changeLog, this);
        }

        if (!expectedResult.equals(result)) {
            throw new PreconditionFailedException("SQL Precondition failed.  Expected '"+expectedResult+"' got '"+result+"'", changeLog, this);
        }

    } catch (DatabaseException e) {
        throw new PreconditionErrorException(e, changeLog, this);
    }
}
 

import liquibase.executor.ExecutorService; //导入依赖的package包/类
public DatabaseChangeLogLock[] listLocks() throws LockException {
    try {
        if (!database.hasDatabaseChangeLogLockTable()) {
            return new DatabaseChangeLogLock[0];
        }

        List<DatabaseChangeLogLock> allLocks = new ArrayList<DatabaseChangeLogLock>();
        SqlStatement sqlStatement = new SelectFromDatabaseChangeLogLockStatement("ID", "LOCKED", "LOCKGRANTED", "LOCKEDBY");
        List<Map> rows = ExecutorService.getInstance().getExecutor(database).queryForList(sqlStatement);
        for (Map columnMap : rows) {
            Object lockedValue = columnMap.get("LOCKED");
            Boolean locked;
            if (lockedValue instanceof Number) {
                locked = ((Number) lockedValue).intValue() == 1;
            } else {
                locked = (Boolean) lockedValue;
            }
            if (locked != null && locked) {
                allLocks.add(new DatabaseChangeLogLock(((Number) columnMap.get("ID")).intValue(), (Date) columnMap.get("LOCKGRANTED"), (String) columnMap.get("LOCKEDBY")));
            }
        }
        return allLocks.toArray(new DatabaseChangeLogLock[allLocks.size()]);
    } catch (Exception e) {
        throw new LockException(e);
    }
}
 

import liquibase.executor.ExecutorService; //导入依赖的package包/类
protected void readSequences(DatabaseSnapshot snapshot, String schema, DatabaseMetaData databaseMetaData)
		throws DatabaseException {
	Database database = snapshot.getDatabase();
	if (database.supportsSequences()) {
		updateListeners("Reading sequences for " + database.toString() + " ...");

		String convertedSchemaName = database.convertRequestedSchemaToSchema(schema);

		// noinspection unchecked
		List<String> sequenceNames = (List<String>) ExecutorService.getInstance().getExecutor(database)
				.queryForList(new SelectSequencesStatement(schema), String.class);

		if (sequenceNames != null) {
			for (String sequenceName : sequenceNames) {
				Sequence seq = new Sequence();
				seq.setName(sequenceName.trim());
				seq.setSchema(convertedSchemaName);

				snapshot.getSequences().add(seq);
			}
		}
	} else {
		updateListeners("Sequences not supported for " + database.toString() + " ...");
	}
}
 

import liquibase.executor.ExecutorService; //导入依赖的package包/类
@Override
protected void readSequences(DatabaseSnapshot snapshot, String schema, DatabaseMetaData databaseMetaData) throws DatabaseException {
    Database database = snapshot.getDatabase();
    updateListeners("Reading sequences for " + database.toString() + " ...");

    String convertedSchemaName = database.convertRequestedSchemaToSchema(schema);

    if (database.supportsSequences()) {
        //noinspection unchecked
        List<String> sequenceNamess = (List<String>) ExecutorService.getInstance().getExecutor(database).queryForList(new SelectSequencesStatement(schema), String.class);


        for (String sequenceName : sequenceNamess) {
            Sequence seq = new Sequence();
            seq.setName(sequenceName.trim());
            seq.setName(convertedSchemaName);

            snapshot.getSequences().add(seq);
        }
    }
}
 

import liquibase.executor.ExecutorService; //导入依赖的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.ExecutorService; //导入依赖的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.ExecutorService; //导入依赖的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.ExecutorService; //导入依赖的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.ExecutorService; //导入依赖的package包/类
/**
 * Sets checksums to null so they will be repopulated next run
 */
public void clearCheckSums() throws LiquibaseException {
    log.info("Clearing database change log checksums");
    LockService lockService = LockService.getInstance(database);
    lockService.waitForLock();

    try {
        checkDatabaseChangeLogTable(false, null, null);

        UpdateStatement updateStatement = new UpdateStatement(getDatabase().getLiquibaseSchemaName(), getDatabase().getDatabaseChangeLogTableName());
        updateStatement.addNewColumnValue("MD5SUM", null);
        ExecutorService.getInstance().getExecutor(database).execute(updateStatement);
        getDatabase().commit();
    } finally {
        lockService.releaseLock();
    }
}
 

import liquibase.executor.ExecutorService; //导入依赖的package包/类
@Override
protected void replaceChecksum(ChangeSet changeSet) throws DatabaseException {
    ExecutorService.getInstance().getExecutor(getDatabase()).execute(new UpdateChangeSetChecksumStatement(changeSet));

    getDatabase().commit();
    reset();
}
 

import liquibase.executor.ExecutorService; //导入依赖的package包/类
@Override
public void setExecType(ChangeSet changeSet, ChangeSet.ExecType execType) throws DatabaseException {
    Database database = getDatabase();

    ExecutorService.getInstance().getExecutor(database).execute(new MarkChangeSetRanStatement(changeSet, execType));
    getDatabase().commit();
    if (this.ranChangeSetList != null) {
        this.ranChangeSetList.add(new RanChangeSet(changeSet, execType, null, null));
    }

}
 

import liquibase.executor.ExecutorService; //导入依赖的package包/类
@Override
public void removeFromHistory(final ChangeSet changeSet) throws DatabaseException {
    Database database = getDatabase();
    ExecutorService.getInstance().getExecutor(database).execute(new RemoveChangeSetRanStatusStatement(changeSet));
    getDatabase().commit();

    if (this.ranChangeSetList != null) {
        this.ranChangeSetList.remove(new RanChangeSet(changeSet));
    }
}
 

import liquibase.executor.ExecutorService; //导入依赖的package包/类
@Override
public int getNextSequenceValue() throws LiquibaseException {
    if (lastChangeSetSequenceValue == null) {
        if (getDatabase().getConnection() == null) {
            lastChangeSetSequenceValue = 0;
        } else {
            lastChangeSetSequenceValue = ExecutorService.getInstance().getExecutor(getDatabase()).queryForInt(new GetNextChangeSetSequenceValueStatement());
        }
    }

    return ++lastChangeSetSequenceValue;
}