/**
   * This operation updates the state of the database to indicate that all scripts have been
   * executed, without actually executing them. This can be useful when you want to start using
   * DbMaintain on an existing database, or after having fixed a problem directly on the database.
   */
  public void markDatabaseAsUpToDate() {
    try {
      executedScriptInfoSource.clearAllExecutedScripts();

      SortedSet<Script> allScripts = scriptRepository.getAllScripts();
      for (Script script : allScripts) {
        executedScriptInfoSource.registerExecutedScript(
            new ExecutedScript(script, new Date(), true));
      }
      logger.info("The database has been marked as up-to-date");
    } finally {
      sqlHandler.closeAllConnections();
    }
  }
  /**
   * This operation can be used to bring the database to the latest version. First it checks which
   * scripts were already applied to the database and executes the new scripts or the updated
   * repeatable scripts. If an existing incremental script was changed, removed, or if a new
   * incremental script has been added with a lower index than one that was already executed, an
   * error is given; unless the <fromScratch> option is enabled: in that case all database objects
   * at the end.
   *
   * @param dryRun if true, no updates have to be performed on the database - we do a simulation of
   *     the database update instead of actually performing the database update.
   * @return whether updates were performed on the database
   */
  public boolean updateDatabase(boolean dryRun) {
    try {
      ScriptUpdates scriptUpdates = getScriptUpdates();

      if (!getIncrementalScriptsThatFailedDuringLastUpdate().isEmpty()
          && !scriptUpdates.hasIrregularScriptUpdates()) {
        ExecutedScript failedExecutedScriptScript =
            getIncrementalScriptsThatFailedDuringLastUpdate().first();
        throw new DbMaintainException(
            "During the latest update, the execution of the following incremental script failed: "
                + failedExecutedScriptScript
                + ". \nThis problem must be fixed before any other "
                + "updates can be performed.\n"
                + getErrorScriptOptionsMessage(failedExecutedScriptScript.getScript()));
      }

      if (!getRepeatableScriptsThatFailedDuringLastUpdate().isEmpty()
          && !scriptUpdates.hasIrregularScriptUpdates()) {
        ExecutedScript failedScript = getRepeatableScriptsThatFailedDuringLastUpdate().first();
        if (!scriptUpdates
                .getRegularlyAddedOrModifiedScripts()
                .contains(new ScriptUpdate(REPEATABLE_SCRIPT_UPDATED, failedScript.getScript()))
            && !scriptUpdates
                .getRegularlyDeletedRepeatableScripts()
                .contains(new ScriptUpdate(REPEATABLE_SCRIPT_DELETED, failedScript.getScript()))) {
          throw new DbMaintainException(
              "During the latest update, the execution of following repeatable script failed: "
                  + getRepeatableScriptsThatFailedDuringLastUpdate().first()
                  + ". \nThis problem must be fixed "
                  + "before any other updates can be performed.");
        }
      }

      if (scriptUpdates.isEmpty()) {
        logger.info("The database is up to date");
        return false;
      }

      boolean recreateFromScratch = false;
      if (fromScratchEnabled && isInitialDatabaseUpdate()) {
        logger.info(
            "The database is updated for the first time. The database is cleared to be sure that we start with a clean database");
        recreateFromScratch = true;
      }

      if (scriptUpdates.hasIrregularScriptUpdates()) {
        if (fromScratchEnabled) {
          // Recreate the database from scratch
          logger.info(
              "The database is recreated from scratch, since following irregular script updates were detected:\n"
                  + scriptUpdatesFormatter.formatScriptUpdates(
                      scriptUpdates.getIrregularScriptUpdates()));
          recreateFromScratch = true;
        } else {
          throw new DbMaintainException(
              "Following irregular script updates were detected:\n"
                  + scriptUpdatesFormatter.formatScriptUpdates(
                      scriptUpdates.getIrregularScriptUpdates())
                  + "\nBecause of this, dbmaintain can't perform the update. To solve this problem, you can do one of the following:\n"
                  + "  1: Revert the irregular updates and use regular script updates instead\n"
                  + "  2: Enable the fromScratch option so that the database is recreated from scratch (all data will be lost)\n"
                  + "  3: Perform the updates manually on the database and invoke the markDatabaseAsUpToDate operation (error prone)\n");
        }
      }

      if (recreateFromScratch) {
        if (baseLineRevision != null) {
          throw new DbMaintainException(
              "Unable to recreate the database from scratch: a baseline revision is set.\n"
                  + "After clearing the database only scripts starting from the baseline revision would have been executed. The other scripts would have been ignored resulting in an inconsistent database state.\n"
                  + "Please clear the baseline revision if you want to perform a from scratch update.\n"
                  + "Another option is to explicitly clear the database using the clear task and then performing the update.");
        }
        logger.info("The database is cleared, and all database scripts are executed.");
        if (!dryRun) {
          dbClearer.clearDatabase();
          executedScriptInfoSource.resetCachedState();
          executeScripts(scriptRepository.getAllUpdateScripts());
        }
      } else {
        logger.info(
            "The database is updated incrementally, since following regular script updates were detected:\n"
                + scriptUpdatesFormatter.formatScriptUpdates(
                    scriptUpdates.getRegularScriptUpdates()));
        if (!dryRun) {
          // If the disable constraints option is enabled, disable all FK and not null constraints
          if (disableConstraints) {
            constraintsDisabler.disableConstraints();
          }
          // If cleandb is enabled, remove all data from the database.
          if (cleanDb) {
            dbCleaner.cleanDatabase();
          }
          // If there are incremental patch scripts with a lower index and the option
          // allowOutOfSequenceExecutionOfPatches
          // is enabled, execute them first
          executeScriptUpdates(scriptUpdates.getRegularlyAddedPatchScripts());
          // Execute all new incremental and all new or modified repeatable scripts
          executeScriptUpdates(scriptUpdates.getRegularlyAddedOrModifiedScripts());
          // If repeatable scripts were removed, also remove them from the executed scripts
          removeDeletedRepeatableScriptsFromExecutedScripts(
              scriptUpdates.getRegularlyDeletedRepeatableScripts());
          // If regular script renames were detected, update the executed script records to reflect
          // this
          performRegularScriptRenamesInExecutedScripts(scriptUpdates.getRegularlyRenamedScripts());
        }
      }
      if (scriptUpdates.noUpdatesOtherThanRepeatableScriptDeletionsOrRenames()) {
        logger.info(
            "No script updates were detected, except for repeatable script deletions and script renames. Therefore, actions such as the execution of postprocessing scripts and disabling the constraints are skipped.");
        return false;
      }

      if (!dryRun) {
        // Execute all post processing scripts
        executePostprocessingScripts();

        // If the disable constraints option is enabled, disable all FK and not null constraints
        if (disableConstraints) {
          constraintsDisabler.disableConstraints();
        }
        // the scripts could have added data, if cleandb is enabled, remove all data from the
        // database.
        if (cleanDb) {
          dbCleaner.cleanDatabase();
        }
        // If the update sequences option is enabled, update all sequences to have a value equal to
        // or higher than the configured threshold
        if (updateSequences) {
          sequenceUpdater.updateSequences();
        }
        logger.info("The database has been updated successfully.");
      }
      return true;

    } finally {
      sqlHandler.closeAllConnections();
    }
  }