public void check(Database database, DatabaseChangeLog changeLog, ChangeSet changeSet)
     throws PreconditionFailedException, PreconditionErrorException {
   try {
     boolean checkPassed;
     if (getForeignKeyTableName() == null) {
       checkPassed =
           DatabaseSnapshotGeneratorFactory.getInstance()
                   .createSnapshot(database, getSchemaName(), null)
                   .getForeignKey(getForeignKeyName())
               != null;
     } else { // much faster if we can limit to correct table
       checkPassed =
           DatabaseSnapshotGeneratorFactory.getInstance()
                   .getGenerator(database)
                   .getForeignKeyByForeignKeyTable(
                       getSchemaName(), getForeignKeyTableName(), getForeignKeyName(), database)
               != null;
     }
     if (!checkPassed) {
       String message = "Foreign Key " + database.escapeStringForDatabase(getForeignKeyName());
       if (getForeignKeyTableName() != null) {
         message += " on table " + getForeignKeyTableName();
       }
       message += " does not exist";
       throw new PreconditionFailedException(message, changeLog, this);
     }
   } catch (DatabaseException e) {
     throw new PreconditionErrorException(e, changeLog, this);
   }
 }
Esempio n. 2
0
 @Override
 public boolean hasDatabaseChangeLogLockTable() throws DatabaseException {
   if (canCacheLiquibaseTableInfo && hasDatabaseChangeLogLockTable) {
     return true;
   }
   boolean hasTable =
       DatabaseSnapshotGeneratorFactory.getInstance()
           .getGenerator(this)
           .hasDatabaseChangeLogLockTable(this);
   if (canCacheLiquibaseTableInfo) {
     hasDatabaseChangeLogLockTable = hasTable;
   }
   return hasTable;
 }
  @Override
  public void execute() throws BuildException {
    super.execute();

    Liquibase liquibase = null;
    try {
      PrintStream writer = createPrintStream();
      if (writer == null) {
        throw new BuildException("generateChangeLog requires outputFile to be set");
      }

      liquibase = createLiquibase();

      Database database = liquibase.getDatabase();
      DiffControl diffControl =
          new DiffControl(
              getDefaultCatalogName(), getDefaultSchemaName(), null, null, getDiffTypes());
      diffControl.setDataDir(getDataDir());

      DatabaseSnapshot referenceSnapshot =
          DatabaseSnapshotGeneratorFactory.getInstance()
              .createSnapshot(database, diffControl, DiffControl.DatabaseRole.REFERENCE);

      DiffResult diffResult =
          DiffGeneratorFactory.getInstance()
              .compare(referenceSnapshot, new DatabaseSnapshot(database), diffControl);
      //			diff.addStatusListener(new OutDiffStatusListener());

      if (getChangeLogFile() == null) {
        new DiffToChangeLog(diffResult).print(writer);
      } else {
        new DiffToChangeLog(diffResult).print(getChangeLogFile());
      }

      writer.flush();
      writer.close();
    } catch (Exception e) {
      throw new BuildException(e);
    } finally {
      closeDatabase(liquibase);
    }
  }
 public void check(Database database, DatabaseChangeLog changeLog, ChangeSet changeSet)
     throws PreconditionFailedException, PreconditionErrorException {
   String currentSchemaName;
   try {
     currentSchemaName =
         getSchemaName() == null
             ? (database == null ? null : database.getDefaultSchemaName())
             : getSchemaName();
     if (!DatabaseSnapshotGeneratorFactory.getInstance()
         .getGenerator(database)
         .hasView(currentSchemaName, getViewName(), database)) {
       throw new PreconditionFailedException(
           "View "
               + database.escapeTableName(currentSchemaName, getViewName())
               + " does not exist",
           changeLog,
           this);
     }
   } catch (PreconditionFailedException e) {
     throw e;
   } catch (Exception e) {
     throw new PreconditionErrorException(e, changeLog, this);
   }
 }
Esempio n. 5
0
  /**
   * Drops all objects owned by the connected user.
   *
   * @param schema
   */
  @Override
  public void dropDatabaseObjects(String schema) throws DatabaseException {
    try {
      DatabaseSnapshotGeneratorFactory factory = DatabaseSnapshotGeneratorFactory.getInstance();
      SnapshotContext context = new SnapshotContext();
      context.setDatabase(this);
      context.setSchema(schema);
      context.setListeners(new HashSet<DiffStatusListener>());
      DatabaseSnapshot snapshot = factory.createSnapshot(context);

      List<Change> dropChanges = new ArrayList<Change>();

      for (View view : snapshot.getViews()) {
        DropViewChange dropChange = new DropViewChange();
        dropChange.setViewName(view.getName());
        dropChange.setSchemaName(schema);

        dropChanges.add(dropChange);
      }

      if (!supportsForeignKeyDisable()) {
        for (ForeignKey fk : snapshot.getForeignKeys()) {
          DropForeignKeyConstraintChange dropFK = new DropForeignKeyConstraintChange();
          dropFK.setBaseTableSchemaName(schema);
          dropFK.setBaseTableName(fk.getForeignKeyTable().getName());
          dropFK.setConstraintName(fk.getName());

          dropChanges.add(dropFK);
        }
      }

      // for (Index index : snapshotGenerator.getIndexes()) {
      // DropIndexChange dropChange = new DropIndexChange();
      // dropChange.setIndexName(index.getName());
      // dropChange.setSchemaName(schema);
      // dropChange.setTableName(index.getTableName());
      //
      // dropChanges.add(dropChange);
      // }

      for (Table table : snapshot.getTables()) {
        DropTableChange dropChange = new DropTableChange();
        dropChange.setSchemaName(schema);
        dropChange.setTableName(table.getName());
        if (supportsDropTableCascadeConstraints()) {
          dropChange.setCascadeConstraints(true);
        }

        dropChanges.add(dropChange);
      }

      if (this.supportsSequences()) {
        for (Sequence seq : snapshot.getSequences()) {
          DropSequenceChange dropChange = new DropSequenceChange();
          dropChange.setSequenceName(seq.getName());
          dropChange.setSchemaName(schema);

          dropChanges.add(dropChange);
        }
      }

      if (snapshot.hasDatabaseChangeLogTable()) {
        dropChanges.add(new AnonymousChange(new ClearDatabaseChangeLogTableStatement(schema)));
      }

      final boolean reEnableFK = supportsForeignKeyDisable() && disableForeignKeyChecks();
      try {
        for (Change change : dropChanges) {
          for (SqlStatement statement : change.generateStatements(this)) {
            ExecutorService.getInstance().getExecutor(this).execute(statement);
          }
        }
      } finally {
        if (reEnableFK) {
          enableForeignKeyChecks();
        }
      }

    } finally {
      this.commit();
    }
  }
Esempio n. 6
0
  /**
   * 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
   */
  @Override
  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;
    }
  }
Esempio n. 7
0
 public Table getTable(String schemaName, String tableName) throws DatabaseException {
   return DatabaseSnapshotGeneratorFactory.getInstance()
       .getGenerator(this)
       .getTable(schemaName, tableName, this);
 }