@Override
  public Change[] fixChanged(
      DatabaseObject changedObject,
      ObjectDifferences differences,
      DiffOutputControl control,
      Database referenceDatabase,
      final Database comparisonDatabase,
      ChangeGeneratorChain chain) {
    Table table = (Table) changedObject;

    Difference changedRemarks = differences.getDifference("remarks");
    if (changedRemarks != null) {
      SetTableRemarksChange change = new SetTableRemarksChange();
      if (control.getIncludeCatalog()) {
        change.setCatalogName(table.getSchema().getCatalogName());
      }
      if (control.getIncludeSchema()) {
        change.setSchemaName(table.getSchema().getName());
      }

      change.setTableName(table.getName());
      change.setRemarks(table.getRemarks());

      return new Change[] {change};
    }

    return null;
  }
  @Override
  public Change[] fixUnexpected(
      DatabaseObject unexpectedObject,
      DiffOutputControl control,
      Database referenceDatabase,
      Database comparisonDatabase,
      ChangeGeneratorChain chain) {
    Sequence sequence = (Sequence) unexpectedObject;

    DropSequenceChange change = new DropSequenceChange();
    change.setSequenceName(sequence.getName());
    if (control.getIncludeCatalog()) {
      change.setCatalogName(sequence.getSchema().getCatalogName());
    }
    if (control.getIncludeSchema()) {
      change.setSchemaName(sequence.getSchema().getName());
    }

    return new Change[] {change};
  }
  @Override
  public Change[] fixMissing(
      DatabaseObject missingObject,
      DiffOutputControl control,
      Database referenceDatabase,
      Database comparisonDatabase,
      ChangeGeneratorChain chain) {
    List<Change> returnList = new ArrayList<Change>();

    UniqueConstraint uc = (UniqueConstraint) missingObject;

    if (uc.getTable() == null) {
      return null;
    }

    AddUniqueConstraintChange change = new AddUniqueConstraintChange();
    change.setTableName(uc.getTable().getName());
    if (uc.getBackingIndex() != null && control.getIncludeTablespace()) {
      change.setTablespace(uc.getBackingIndex().getTablespace());
    }
    if (control.getIncludeCatalog()) {
      change.setCatalogName(uc.getTable().getSchema().getCatalogName());
    }
    if (control.getIncludeSchema()) {
      change.setSchemaName(uc.getTable().getSchema().getName());
    }
    change.setConstraintName(uc.getName());
    change.setColumnNames(uc.getColumnNames());
    change.setDeferrable(uc.isDeferrable() ? Boolean.TRUE : null);
    change.setInitiallyDeferred(uc.isInitiallyDeferred() ? Boolean.TRUE : null);
    change.setDisabled(uc.isDisabled() ? Boolean.TRUE : null);

    if (comparisonDatabase instanceof OracleDatabase) {
      Index backingIndex = uc.getBackingIndex();
      if (backingIndex != null && backingIndex.getName() != null) {
        Change[] changes =
            ChangeGeneratorFactory.getInstance()
                .fixMissing(backingIndex, control, referenceDatabase, comparisonDatabase);
        if (changes != null) {
          returnList.addAll(Arrays.asList(changes));

          change.setForIndexName(backingIndex.getName());
          Schema schema = backingIndex.getSchema();
          if (schema != null) {
            if (control.getIncludeCatalog()) {
              change.setForIndexCatalogName(schema.getCatalogName());
            }
            if (control.getIncludeSchema()) {
              change.setForIndexSchemaName(schema.getName());
            }
          }
        }
      }
    }

    Index backingIndex = uc.getBackingIndex();
    //        if (backingIndex == null) {
    //            Index exampleIndex = new Index().setTable(uc.getTable());
    //            for (String col : uc.getColumns()) {
    //                exampleIndex.getColumns().add(col);
    //            }
    //            control.setAlreadyHandledMissing(exampleIndex);
    //        } else {
    control.setAlreadyHandledMissing(backingIndex);
    //        }

    returnList.add(change);

    return returnList.toArray(new Change[returnList.size()]);
  }
  @Override
  public Change[] fixMissing(
      DatabaseObject missingObject,
      DiffOutputControl control,
      Database referenceDatabase,
      Database comparisonDatabase,
      ChangeGeneratorChain chain) {
    List<Change> returnList = new ArrayList<Change>();

    PrimaryKey pk = (PrimaryKey) missingObject;

    AddPrimaryKeyChange change = new AddPrimaryKeyChange();
    change.setTableName(pk.getTable().getName());
    if (control.getIncludeCatalog()) {
      change.setCatalogName(pk.getTable().getSchema().getCatalogName());
    }
    if (control.getIncludeSchema()) {
      change.setSchemaName(pk.getTable().getSchema().getName());
    }
    change.setConstraintName(pk.getName());
    change.setColumnNames(pk.getColumnNames());
    if (control.getIncludeTablespace()) {
      change.setTablespace(pk.getTablespace());
    }

    if (referenceDatabase instanceof MSSQLDatabase
        && pk.getBackingIndex() != null
        && pk.getBackingIndex().getClustered() != null
        && !pk.getBackingIndex().getClustered()) {
      change.setClustered(false);
    }

    if (comparisonDatabase instanceof OracleDatabase
        || (comparisonDatabase instanceof DB2Database
            && pk.getBackingIndex() != null
            && !comparisonDatabase.isSystemObject(pk.getBackingIndex()))) {
      Index backingIndex = pk.getBackingIndex();
      if (backingIndex != null && backingIndex.getName() != null) {
        try {
          if (!control.getIncludeCatalog() && !control.getIncludeSchema()) {
            CatalogAndSchema schema =
                comparisonDatabase.getDefaultSchema().customize(comparisonDatabase);
            backingIndex
                .getTable()
                .setSchema(
                    schema.getCatalogName(),
                    schema
                        .getSchemaName()); // set table schema so it is found in the correct schema
          }
          if (referenceDatabase.equals(comparisonDatabase)
              || !SnapshotGeneratorFactory.getInstance().has(backingIndex, comparisonDatabase)) {
            Change[] fixes =
                ChangeGeneratorFactory.getInstance()
                    .fixMissing(backingIndex, control, referenceDatabase, comparisonDatabase);

            if (fixes != null) {
              for (Change fix : fixes) {
                if (fix != null) {
                  returnList.add(fix);
                }
              }
            }
          }
        } catch (Exception e) {
          throw new UnexpectedLiquibaseException(e);
        }

        change.setForIndexName(backingIndex.getName());
        Schema schema = backingIndex.getSchema();
        if (schema != null) {
          if (control.getIncludeCatalog()) {
            change.setForIndexCatalogName(schema.getCatalogName());
          }
          if (control.getIncludeSchema()) {
            change.setForIndexSchemaName(schema.getName());
          }
        }
      }
    }

    control.setAlreadyHandledMissing(pk.getBackingIndex());
    returnList.add(change);

    return returnList.toArray(new Change[returnList.size()]);
  }