Coverage Report - liquibase.change.core.DropUniqueConstraintChange
 
Classes in this File Line Coverage Branch Coverage Complexity
DropUniqueConstraintChange
61%
16/26
100%
4/4
1.25
DropUniqueConstraintChange$1
0%
0/7
0%
0/2
1.25
 
 1  
 package liquibase.change.core;
 2  
 
 3  
 import liquibase.change.AbstractChange;
 4  
 import liquibase.change.ChangeMetaData;
 5  
 import liquibase.change.ColumnConfig;
 6  
 import liquibase.database.Database;
 7  
 import liquibase.database.core.SQLiteDatabase;
 8  
 import liquibase.database.core.SQLiteDatabase.AlterTableVisitor;
 9  
 import liquibase.database.core.SybaseASADatabase;
 10  
 import liquibase.database.structure.Index;
 11  
 import liquibase.statement.SqlStatement;
 12  
 import liquibase.statement.core.DropUniqueConstraintStatement;
 13  
 import liquibase.util.StringUtils;
 14  
 
 15  
 import java.util.ArrayList;
 16  
 import java.util.List;
 17  
 
 18  
 /**
 19  
  * Removes an existing unique constraint.
 20  
  */
 21  
 public class DropUniqueConstraintChange extends AbstractChange {
 22  
     private String schemaName;
 23  
     private String tableName;
 24  
     private String constraintName;
 25  
     /**
 26  
      * Sybase ASA does drop unique constraint not by name, but using list of the columns in unique clause.
 27  
      */
 28  
     private String uniqueColumns;
 29  
 
 30  
     public DropUniqueConstraintChange() {
 31  21
         super("dropUniqueConstraint", "Drop Unique Constraint", ChangeMetaData.PRIORITY_DEFAULT);
 32  21
     }
 33  
 
 34  
     public String getSchemaName() {
 35  47
         return schemaName;
 36  
     }
 37  
 
 38  
     public void setSchemaName(String schemaName) {
 39  7
         this.schemaName = StringUtils.trimToNull(schemaName);
 40  7
     }
 41  
 
 42  
     public String getTableName() {
 43  47
         return tableName;
 44  
     }
 45  
 
 46  
     public void setTableName(String tableName) {
 47  8
         this.tableName = tableName;
 48  8
     }
 49  
 
 50  
     public String getConstraintName() {
 51  47
         return constraintName;
 52  
     }
 53  
 
 54  
     public void setConstraintName(String constraintName) {
 55  8
         this.constraintName = constraintName;
 56  8
     }
 57  
 
 58  
     public String getUniqueColumns() {
 59  0
         return uniqueColumns;
 60  
     }
 61  
 
 62  
     public void setUniqueColumns(String uniqueColumns) {
 63  0
         this.uniqueColumns = uniqueColumns;
 64  0
     }
 65  
 
 66  
     public SqlStatement[] generateStatements(Database database) {
 67  
 
 68  
         // todo if (database instanceof SQLiteDatabase) {
 69  
         // // return special statements for SQLite databases
 70  
         // return generateStatementsForSQLiteDatabase(database);
 71  
         // }
 72  46
         DropUniqueConstraintStatement statement = new DropUniqueConstraintStatement(
 73  
                 getSchemaName() == null ? database.getDefaultSchemaName() : getSchemaName(), getTableName(),
 74  
                 getConstraintName());
 75  46
         if (database instanceof SybaseASADatabase) {
 76  3
             statement.setUniqueColumns(uniqueColumns);
 77  
         }
 78  46
         return new SqlStatement[] { statement };
 79  
     }
 80  
 
 81  
     private SqlStatement[] generateStatementsForSQLiteDatabase(Database database) {
 82  
 
 83  
         // SQLite does not support this ALTER TABLE operation until now.
 84  
         // For more information see: http://www.sqlite.org/omitted.html.
 85  
         // This is a small work around...
 86  
 
 87  
         // Note: The attribute "constraintName" is used to pass the column
 88  
         // name instead of the constraint name.
 89  
 
 90  0
         List<SqlStatement> statements = new ArrayList<SqlStatement>();
 91  
 
 92  
         // define alter table logic
 93  0
         AlterTableVisitor rename_alter_visitor = new AlterTableVisitor() {
 94  
             public ColumnConfig[] getColumnsToAdd() {
 95  0
                 return new ColumnConfig[0];
 96  
             }
 97  
 
 98  
             public boolean copyThisColumn(ColumnConfig column) {
 99  0
                 return true;
 100  
             }
 101  
 
 102  
             public boolean createThisColumn(ColumnConfig column) {
 103  0
                 if (column.getName().equals(getConstraintName())) {
 104  0
                     column.getConstraints().setUnique(false);
 105  
                 }
 106  0
                 return true;
 107  
             }
 108  
 
 109  
             public boolean createThisIndex(Index index) {
 110  0
                 return true;
 111  
             }
 112  
         };
 113  
 
 114  
         try {
 115  
             // alter table
 116  0
             statements.addAll(SQLiteDatabase.getAlterTableStatements(rename_alter_visitor, database, getSchemaName(),
 117  
                     getTableName()));
 118  0
         } catch (Exception e) {
 119  0
             e.printStackTrace();
 120  0
         }
 121  
 
 122  0
         return statements.toArray(new SqlStatement[statements.size()]);
 123  
     }
 124  
 
 125  
     public String getConfirmationMessage() {
 126  1
         return "Unique constraint " + getConstraintName() + " dropped from " + getTableName();
 127  
     }
 128  
 }