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);
}
}
