@Override
  public AnalysisResult analyse(TestSuiteResult originalResults) {
    // Get normal results
    AnalysisResult result = new AnalysisResult();

    // Build map of changed tables
    this.changedTableMap = new HashMap<>();
    executor = Executors.newFixedThreadPool(4);
    for (int id = 0; id < mutants.size(); id++) {
      Mutant<Schema> mutant = mutants.get(id);
      executor.submit(new ChangedTableTask(changedTableMap, id, mutant));
    }
    executor.shutdown();
    try {
      executor.awaitTermination(1, TimeUnit.DAYS);
    } catch (InterruptedException ex) {
      throw new RuntimeException(ex);
    }

    // Build the meta-mutant schema and SQL statements
    Schema metamutant = MutationAnalysisUtils.mergeMutantsParallel(schema, mutants);
    createStmts = sqlWriter.writeCreateTableStatements(metamutant);
    dropStmts = sqlWriter.writeDropTableStatements(metamutant, true);
    deleteStmts = sqlWriter.writeDeleteFromTableStatements(metamutant);

    // Build map of results
    this.resultMap = new HashMap<>();
    for (int i = 0; i < mutants.size(); i++) {
      resultMap.put(i, new TestSuiteResult());
    }

    // Execute test suite
    executeDropStmts(databaseInteractor);
    executeCreateStmts(databaseInteractor);
    for (TestCase testCase : testSuite.getTestCases()) {
      executeDeleteStmts(databaseInteractor);
      TestCaseResult normalTestResult = null;
      Map<Integer, TestCaseResult> failedMutants = new HashMap<>();

      Data data = testCase.getState();
      normalTestResult = executeInserts(data, normalTestResult, failedMutants, testCase);
      data = testCase.getData();
      normalTestResult = executeInserts(data, normalTestResult, failedMutants, testCase);
      if (normalTestResult == null) {
        for (int i = 0; i < mutants.size(); i++) {
          if (!failedMutants.containsKey(i)) {
            resultMap.get(i).add(testCase, TestCaseResult.SuccessfulTestCaseResult);
          }
        }
      }
    }

    // Build the TestSuiteResult objects
    for (int i = 0; i < mutants.size(); i++) {
      TestSuiteResult mutantResult = resultMap.get(i);
      if (!originalResults.equals(mutantResult)) {
        result.addKilled(mutants.get(i));
      } else {
        result.addLive(mutants.get(i));
      }
    }

    executeDropStmts(databaseInteractor);
    return result;
  }
  @Override
  public void task() {
    // Setup
    if (inputfolder == null) {
      inputfolder =
          locationsConfiguration.getResultsDir()
              + File.separator
              + "generatedresults"
              + File.separator;
    }
    if (outputfolder == null) {
      outputfolder = locationsConfiguration.getResultsDir() + File.separator;
    }

    // Start results file
    CSVResult result = new CSVResult();
    result.addValue("technique", this.getClass().getSimpleName());
    result.addValue("dbms", databaseConfiguration.getDbms());
    result.addValue("casestudy", casestudy);
    result.addValue("trial", trial);

    // Instantiate the DBMS and related objects
    DBMS dbms = DBMSFactory.instantiate(databaseConfiguration.getDbms());
    SQLWriter sqlWriter = dbms.getSQLWriter();
    DatabaseInteractor databaseInteractor =
        dbms.getDatabaseInteractor(casestudy, databaseConfiguration, locationsConfiguration);

    if (databaseInteractor.getTableCount() != 0) {
      LOGGER.log(
          Level.SEVERE,
          "Potential dirty database detected: technique={0}, casestudy={1}, trial={2}",
          new Object[] {this.getClass().getSimpleName(), casestudy, trial});
    }

    // Get the required schema class
    Schema schema;
    try {
      schema = (Schema) Class.forName(casestudy).newInstance();
    } catch (ClassNotFoundException | IllegalAccessException | InstantiationException ex) {
      throw new RuntimeException(ex);
    }

    // Load the SQLExecutionReport for the non-mutated schema
    String reportPath = inputfolder + casestudy + ".xml";
    SQLExecutionReport originalReport = XMLSerialiser.load(reportPath);

    // Start mutation timing
    ExperimentTimer timer = new ExperimentTimer();
    timer.start(ExperimentTimer.TimingPoint.TOTAL_TIME);

    // Get the mutation pipeline and generate mutants
    timer.start(ExperimentTimer.TimingPoint.MUTATION_TIME);
    MutationPipeline<Schema> pipeline;
    try {
      pipeline =
          MutationPipelineFactory.<Schema>instantiate(
              mutationPipeline, schema, databaseConfiguration.getDbms());
    } catch (ClassNotFoundException
        | InstantiationException
        | IllegalAccessException
        | InvocationTargetException
        | NoSuchMethodException ex) {
      throw new RuntimeException(ex);
    }
    List<Mutant<Schema>> mutants = pipeline.mutate();
    timer.stop(ExperimentTimer.TimingPoint.MUTATION_TIME);

    // Schemata step: Rename the mutants
    renameMutants(mutants);

    // Schemata step: Build single drop statement
    timer.start(ExperimentTimer.TimingPoint.DROPS_TIME);
    StringBuilder dropBuilder = new StringBuilder();
    for (Mutant<Schema> mutant : mutants) {
      Schema mutantSchema = mutant.getMutatedArtefact();
      for (String statement : sqlWriter.writeDropTableStatements(mutantSchema, true)) {
        dropBuilder.append(statement);
        dropBuilder.append("; ");
        dropBuilder.append(System.lineSeparator());
      }
    }
    String dropStmt = dropBuilder.toString();
    timer.stop(ExperimentTimer.TimingPoint.DROPS_TIME);

    // Schemata step: Build single create statement
    timer.start(ExperimentTimer.TimingPoint.CREATES_TIME);
    StringBuilder createBuilder = new StringBuilder();
    for (Mutant<Schema> mutant : mutants) {
      Schema mutantSchema = mutant.getMutatedArtefact();
      for (String statement : sqlWriter.writeCreateTableStatements(mutantSchema)) {
        createBuilder.append(statement);
        createBuilder.append("; ");
        createBuilder.append(System.lineSeparator());
      }
    }
    String createStmt = createBuilder.toString();
    timer.stop(ExperimentTimer.TimingPoint.CREATES_TIME);

    // Schemata step: Drop existing tables before iterating mutants
    timer.start(ExperimentTimer.TimingPoint.DROPS_TIME);
    if (dropfirst) {
      databaseInteractor.executeUpdate(dropStmt);
    }
    timer.stop(ExperimentTimer.TimingPoint.DROPS_TIME);

    // Schemata step: Create table before iterating mutants
    timer.start(ExperimentTimer.TimingPoint.CREATES_TIME);
    Integer res = databaseInteractor.executeUpdate(createStmt);
    boolean quasiSchema = false;
    if (res.intValue() == -1) {
      quasiSchema = true;
    }
    timer.stop(ExperimentTimer.TimingPoint.CREATES_TIME);

    // Only do mutation analysis if the schema is valid
    int killed = 0;
    if (!quasiSchema) {
      // Begin mutation analysis
      for (int id = 0; id < mutants.size(); id++) {
        Schema mutant = mutants.get(id).getMutatedArtefact();

        LOGGER.log(Level.INFO, "Mutant {0}", id);

        // Schemata step: Generate insert prefix string
        String schemataPrefix = "INSERT INTO mutant_" + (id + 1) + "_";

        // Insert the test data
        timer.start(ExperimentTimer.TimingPoint.INSERTS_TIME);
        List<SQLInsertRecord> insertStmts = originalReport.getInsertStatements();
        ArrayList<String> groupedStatements = new ArrayList<>();
        for (SQLInsertRecord insertRecord : insertStmts) {

          // Schemata step: Rewrite insert for mutant ID
          String insertStmt =
              insertRecord.getStatement().replaceAll("INSERT INTO ", schemataPrefix);
          if (insertRecord.isSatisfying()) {
            groupedStatements.add(insertStmt);
          } else {
            if (!groupedStatements.isEmpty()) {
              int returnCount = databaseInteractor.executeUpdatesAsTransaction(groupedStatements);
              groupedStatements.clear();
              if (returnCount == 0) {
                killed++;
                break;
              }
            }
            int returnCount = databaseInteractor.executeUpdate(insertStmt);
            if (returnCount != insertRecord.getReturnCode()) {
              killed++;
              break; // Stop once killed
            }
          }
        }
        if (!groupedStatements.isEmpty()) {
          int returnCount = databaseInteractor.executeUpdatesAsTransaction(groupedStatements);
          groupedStatements.clear();
          if (returnCount == 0) {
            killed++;
          }
        }
        timer.stop(ExperimentTimer.TimingPoint.INSERTS_TIME);
      }
    }

    // Schemata step: Drop tables after iterating mutants
    timer.start(ExperimentTimer.TimingPoint.DROPS_TIME);
    databaseInteractor.executeUpdate(dropStmt);
    timer.stop(ExperimentTimer.TimingPoint.DROPS_TIME);

    timer.stopAll();
    timer.finalise();

    result.addValue("scorenumerator", (!quasiSchema) ? killed : mutants.size());
    result.addValue("scoredenominator", mutants.size());
    result.addValue("mutationpipeline", mutationPipeline.replaceAll(",", "|"));
    result.addValue("threads", 1);
    result.addValue("totaltime", timer.getTime(ExperimentTimer.TimingPoint.TOTAL_TIME));
    result.addValue("dropstime", timer.getTime(ExperimentTimer.TimingPoint.DROPS_TIME));
    result.addValue("createstime", timer.getTime(ExperimentTimer.TimingPoint.CREATES_TIME));
    result.addValue("insertstime", timer.getTime(ExperimentTimer.TimingPoint.INSERTS_TIME));
    result.addValue("mutationtime", timer.getTime(ExperimentTimer.TimingPoint.MUTATION_TIME));
    result.addValue("paralleltime", timer.getTime(ExperimentTimer.TimingPoint.PARALLEL_TIME));

    if (resultsToFile) {
      if (resultsToOneFile) {
        new CSVFileWriter(outputfolder + "mutationanalysis.dat").write(result);
      } else {
        new CSVFileWriter(outputfolder + casestudy + ".dat").write(result);
      }
    }
    if (resultsToDatabase) {
      new CSVDatabaseWriter(databaseConfiguration, new ExperimentConfiguration()).write(result);
    }
  }