SpatialIndexExistsPrecondition.java

package liquibase.ext.spatial.preconditions;

import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.Set;

import liquibase.changelog.ChangeSet;
import liquibase.changelog.DatabaseChangeLog;
import liquibase.database.Database;
import liquibase.database.core.DerbyDatabase;
import liquibase.database.core.H2Database;
import liquibase.exception.PreconditionErrorException;
import liquibase.exception.PreconditionFailedException;
import liquibase.exception.UnexpectedLiquibaseException;
import liquibase.exception.ValidationErrors;
import liquibase.exception.Warnings;
import liquibase.ext.spatial.xml.XmlConstants;
import liquibase.parser.core.ParsedNode;
import liquibase.parser.core.ParsedNodeException;
import liquibase.precondition.AbstractPrecondition;
import liquibase.precondition.Precondition;
import liquibase.precondition.core.IndexExistsPrecondition;
import liquibase.precondition.core.TableExistsPrecondition;
import liquibase.resource.ResourceAccessor;
import liquibase.structure.DatabaseObject;
import liquibase.structure.core.Column;
import liquibase.structure.core.Index;
import liquibase.structure.core.Schema;
import liquibase.structure.core.Table;
import liquibase.util.StringUtils;

/**
 * <code>SpatialIndexExistsPrecondition</code> determines if a spatial index exists on a specified
 * table.
 */
public class SpatialIndexExistsPrecondition extends AbstractPrecondition {
   private String catalogName;
   private String schemaName;
   private String tableName;
   private String columnNames;
   private String indexName;

   public String getCatalogName() {
      return this.catalogName;
   }

   public void setCatalogName(final String catalogName) {
      this.catalogName = catalogName;
   }

   public String getSchemaName() {
      return this.schemaName;
   }

   public void setSchemaName(final String schemaName) {
      this.schemaName = schemaName;
   }

   public String getTableName() {
      return this.tableName;
   }

   public void setTableName(final String tableName) {
      this.tableName = tableName;
   }

   public String getIndexName() {
      return this.indexName;
   }

   public void setIndexName(final String indexName) {
      this.indexName = indexName;
   }

   public String getColumnNames() {
      return this.columnNames;
   }

   public void setColumnNames(final String columnNames) {
      this.columnNames = columnNames;
   }

   @Override
   public String getName() {
      return "spatialIndexExists";
   }

   @Override
   public Warnings warn(final Database database) {
      return new Warnings();
   }

   @Override
   public ValidationErrors validate(final Database database) {
      final ValidationErrors validationErrors;

      if ((database instanceof DerbyDatabase || database instanceof H2Database)
            && getTableName() == null) {
         validationErrors = new ValidationErrors();
         validationErrors
               .addError("tableName is required for " + database.getDatabaseProductName());
      } else {
         final IndexExistsPrecondition precondition = new IndexExistsPrecondition();
         precondition.setCatalogName(getCatalogName());
         precondition.setSchemaName(getSchemaName());
         precondition.setTableName(getTableName());
         precondition.setIndexName(getIndexName());
         precondition.setColumnNames(getColumnNames());
         validationErrors = precondition.validate(database);
      }
      return validationErrors;
   }

   @Override
   public void check(final Database database, final DatabaseChangeLog changeLog,
         final ChangeSet changeSet) throws PreconditionFailedException, PreconditionErrorException {
      Precondition delegatedPrecondition;
      if (database instanceof DerbyDatabase || database instanceof H2Database) {
         final TableExistsPrecondition precondition = new TableExistsPrecondition();
         precondition.setCatalogName(getCatalogName());
         precondition.setSchemaName(getSchemaName());
         final String tableName = getHatboxTableName();
         precondition.setTableName(tableName);
         delegatedPrecondition = precondition;
      } else {
         final IndexExistsPrecondition precondition = new IndexExistsPrecondition();
         precondition.setCatalogName(getCatalogName());
         precondition.setSchemaName(getSchemaName());
         precondition.setTableName(getTableName());
         precondition.setIndexName(getIndexName());
         precondition.setColumnNames(getColumnNames());
         delegatedPrecondition = precondition;
      }
      delegatedPrecondition.check(database, changeLog, changeSet);
   }

   /**
    * Generates the table name containing the Hatbox index.
    *
    * @return the Hatbox table name.
    */
   protected String getHatboxTableName() {
      final String tableName;
      if (!StringUtils.hasUpperCase(getTableName())) {
         tableName = getTableName() + "_hatbox";
      } else {
         tableName = getTableName() + "_HATBOX";
      }
      return tableName;
   }

   /**
    * Creates an example of the database object for which to check.
    *
    * @param database
    *           the database instance.
    * @param tableName
    *           the table name of the index.
    * @return the database object example.
    */
   public DatabaseObject getExample(final Database database, final String tableName) {
      final Schema schema = new Schema(getCatalogName(), getSchemaName());
      final DatabaseObject example;

      // For GeoDB, the index is another table.
      if (database instanceof DerbyDatabase || database instanceof H2Database) {
         final String correctedTableName = database.correctObjectName(getHatboxTableName(),
               Table.class);
         example = new Table().setName(correctedTableName).setSchema(schema);
      } else {
         example = getIndexExample(database, schema, tableName);
      }
      return example;
   }

   /**
    * Generates the {@link Index} example (taken from {@link IndexExistsPrecondition}).
    *
    * @param database
    *           the database instance.
    * @param schema
    *           the schema instance.
    * @param tableName
    *           the table name of the index.
    * @return the index example.
    */
   protected Index getIndexExample(final Database database, final Schema schema,
         final String tableName) {
      final Index example = new Index();
      if (tableName != null) {
         example.setTable((Table) new Table().setName(
               database.correctObjectName(getTableName(), Table.class)).setSchema(schema));
      }
      example.setName(database.correctObjectName(getIndexName(), Index.class));
      if (StringUtils.trimToNull(getColumnNames()) != null) {
         for (final String columnName : getColumnNames().split("\\s*,\\s*")) {
            final Column column = new Column(database.correctObjectName(columnName, Column.class));
            example.getColumns().add(column);
         }
      }
      return example;
   }

   /**
    * @see liquibase.serializer.LiquibaseSerializable#getSerializedObjectName()
    */
   @Override
   public String getSerializedObjectName() {
      return "spatialIndexExists";
   }

   /**
    * @see liquibase.serializer.LiquibaseSerializable#getSerializableFields()
    */
   @Override
   public Set<String> getSerializableFields() {
      return new LinkedHashSet<String>(Arrays.asList("catalogName", "schemaName", "tableName",
            "columnNames", "indexName"));
   }

   /**
    * @see liquibase.serializer.LiquibaseSerializable#getSerializableFieldValue(java.lang.String)
    */
   @Override
   public Object getSerializableFieldValue(final String field) {
      final Object value;
      if ("catalogName".equals(field)) {
         value = getCatalogName();
      } else if ("schemaName".equals(field)) {
         value = getSchemaName();
      } else if ("tableName".equals(field)) {
         value = getTableName();
      } else if ("columnNames".equals(field)) {
         value = getColumnNames();
      } else if ("indexName".equals(field)) {
         value = getIndexName();
      } else {
         throw new UnexpectedLiquibaseException("Unexpected field request on "
               + getSerializedObjectName() + ": " + field);
      }
      return value;
   }

   /**
    * @see liquibase.serializer.LiquibaseSerializable#getSerializableFieldType(java.lang.String)
    */
   @Override
   public SerializationType getSerializableFieldType(final String field) {
      return SerializationType.NAMED_FIELD;
   }

   /**
    * @see liquibase.serializer.LiquibaseSerializable#getSerializedObjectNamespace()
    */
   @Override
   public String getSerializedObjectNamespace() {
      return XmlConstants.SPATIAL_CHANGELOG_NAMESPACE;
   }

   /**
    * @see liquibase.serializer.LiquibaseSerializable#serialize()
    */
   @Override
   public ParsedNode serialize() throws ParsedNodeException {
      final String namespace = getSerializedObjectNamespace();
      final ParsedNode node = new ParsedNode(namespace, getSerializedObjectName());
      for (final String field : getSerializableFields()) {
         final Object value = getSerializableFieldValue(field);
         node.addChild(namespace, field, value);
      }
      return node;
   }

   /**
    * @see liquibase.precondition.Precondition#load(liquibase.parser.core.ParsedNode,
    *      liquibase.resource.ResourceAccessor)
    */
   @Override
   public void load(final ParsedNode parsedNode, final ResourceAccessor resourceAccessor)
         throws ParsedNodeException {
      final String namespace = null;
      this.catalogName = parsedNode.getChildValue(namespace, "catalogName", String.class);
      this.schemaName = parsedNode.getChildValue(namespace, "schemaName", String.class);
      this.tableName = parsedNode.getChildValue(namespace, "tableName", String.class);
      this.columnNames = parsedNode.getChildValue(namespace, "columnNames", String.class);
      this.indexName = parsedNode.getChildValue(namespace, "indexName", String.class);
   }
}