Coverage Report

Coverage Report - liquibase.database.structure.Index

Classes in this File

Line Coverage

Branch Coverage

Complexity

Index

0/66

0/46

2.143

 package liquibase.database.structure;
 
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 
 import liquibase.util.StringUtils;
 
 public class Index implements DatabaseObject, Comparable<Index> {
 
     /** Marks Index as associated with Primary Key [PK] */
     public final static String MARK_PRIMARY_KEY = "primaryKey";
     /** Marks Index as associated with Foreign Key [FK] */
     public final static String MARK_FOREIGN_KEY = "foreignKey";
     /** Marks Index as associated with Unique Constraint [UC] */
     public final static String MARK_UNIQUE_CONSTRAINT = "uniqueConstraint";
 
     private String name;
     private Table table;
     private String tablespace;
     private Boolean unique;
     private List<String> columns = new ArrayList<String>();
     private String filterCondition;
     // Contain associations of index
     // for example: foreignKey, primaryKey or uniqueConstraint
     private Set<String> associatedWith = new HashSet<String>();
 
     @Override
     public DatabaseObject[] getContainingObjects() {
         return new DatabaseObject[] { table };
     }
 
     public String getName() {
         return name;
     }
 
     public void setName(String name) {
         this.name = name;
     }
 
     public Table getTable() {
         return table;
     }
 
     public void setTable(Table table) {
         this.table = table;
     }
 
     public String getTablespace() {
         return tablespace;
     }
 
     public void setTablespace(String tablespace) {
         this.tablespace = tablespace;
     }
 
     public List<String> getColumns() {
         return columns;
     }
 
     public String getColumnNames() {
         return StringUtils.join(columns, ", ");
     }
 
     public String getFilterCondition() {
         return filterCondition;
     }
 
     public void setFilterCondition(String filterCondition) {
         this.filterCondition = filterCondition;
     }
 
     public void setUnique(Boolean value) {
         this.unique = value;
     }
 
     public Boolean isUnique() {
         return this.unique;
     }
 
     public Set<String> getAssociatedWith() {
         return associatedWith;
     }
 
     public String getAssociatedWithAsString() {
         return StringUtils.join(associatedWith, ",");
     }
 
     public void addAssociatedWith(String item) {
         associatedWith.add(item);
     }
 
     public boolean isAssociatedWith(String keyword) {
         return associatedWith.contains(keyword);
     }
 
     @Override
     public boolean equals(Object o) {
         if (this == o)
             return true;
         if (o == null || getClass() != o.getClass())
             return false;
 
         Index index = (Index) o;
         boolean equals = true;
         for (String column : index.getColumns()) {
             if (!columns.contains(column)) {
                 equals = false;
             }
         }
 
         if (this.unique == null && index.isUnique() == null) {
             // continue check
         } else if (this.unique == null && index.isUnique() != null) {
             equals = false;
         } else if (this.unique != null && index.isUnique() == null) {
             equals = false;
         } else if (!this.unique.equals(index.isUnique())) {
             equals = false;
         }
 
         return equals || table.getName().equalsIgnoreCase(index.table.getName());
 
     }
 
     @Override
     public int hashCode() {
         int result;
         result = table.getName().toUpperCase().hashCode();
         result = 31 * result + columns.hashCode();
         result = 31 * result + (unique == null ? 2 : unique ? 1 : 0);
         return result;
     }
 
     @Override
     public int compareTo(Index o) {
         int returnValue = this.table.getName().compareTo(o.table.getName());
 
         if (returnValue == 0) {
             String thisName = StringUtils.trimToEmpty(this.getName());
             String oName = StringUtils.trimToEmpty(o.getName());
             returnValue = thisName.compareTo(oName);
         }
 
         // We should not have two indexes that have the same name and tablename
         /*
          * if (returnValue == 0) { returnValue = this.getColumnName().compareTo(o.getColumnName()); }
          */
 
         return returnValue;
     }
 
     @Override
     public String toString() {
         StringBuffer stringBuffer = new StringBuffer();
         stringBuffer.append(getName());
         if (this.unique != null && !this.unique) {
             stringBuffer.append(" unique ");
         }
         if (table != null && columns != null) {
             stringBuffer.append(" on ").append(table.getName());
             if (columns != null) {
                 stringBuffer.append("(");
                 for (String column : columns) {
                     stringBuffer.append(column).append(", ");
                 }
                 stringBuffer.delete(stringBuffer.length() - 2, stringBuffer.length());
                 stringBuffer.append(")");
             }
         }
         return stringBuffer.toString();
     }
 }

1		package liquibase.database.structure;
2
3		import java.util.ArrayList;
4		import java.util.HashSet;
5		import java.util.List;
6		import java.util.Set;
7
8		import liquibase.util.StringUtils;
9
10	0	public class Index implements DatabaseObject, Comparable<Index> {
11
12		/** Marks Index as associated with Primary Key [PK] */
13		public final static String MARK_PRIMARY_KEY = "primaryKey";
14		/** Marks Index as associated with Foreign Key [FK] */
15		public final static String MARK_FOREIGN_KEY = "foreignKey";
16		/** Marks Index as associated with Unique Constraint [UC] */
17		public final static String MARK_UNIQUE_CONSTRAINT = "uniqueConstraint";
18
19		private String name;
20		private Table table;
21		private String tablespace;
22		private Boolean unique;
23	0	private List<String> columns = new ArrayList<String>();
24		private String filterCondition;
25		// Contain associations of index
26		// for example: foreignKey, primaryKey or uniqueConstraint
27	0	private Set<String> associatedWith = new HashSet<String>();
28
29		@Override
30		public DatabaseObject[] getContainingObjects() {
31	0	return new DatabaseObject[] { table };
32		}
33
34		public String getName() {
35	0	return name;
36		}
37
38		public void setName(String name) {
39	0	this.name = name;
40	0	}
41
42		public Table getTable() {
43	0	return table;
44		}
45
46		public void setTable(Table table) {
47	0	this.table = table;
48	0	}
49
50		public String getTablespace() {
51	0	return tablespace;
52		}
53
54		public void setTablespace(String tablespace) {
55	0	this.tablespace = tablespace;
56	0	}
57
58		public List<String> getColumns() {
59	0	return columns;
60		}
61
62		public String getColumnNames() {
63	0	return StringUtils.join(columns, ", ");
64		}
65
66		public String getFilterCondition() {
67	0	return filterCondition;
68		}
69
70		public void setFilterCondition(String filterCondition) {
71	0	this.filterCondition = filterCondition;
72	0	}
73
74		public void setUnique(Boolean value) {
75	0	this.unique = value;
76	0	}
77
78		public Boolean isUnique() {
79	0	return this.unique;
80		}
81
82		public Set<String> getAssociatedWith() {
83	0	return associatedWith;
84		}
85
86		public String getAssociatedWithAsString() {
87	0	return StringUtils.join(associatedWith, ",");
88		}
89
90		public void addAssociatedWith(String item) {
91	0	associatedWith.add(item);
92	0	}
93
94		public boolean isAssociatedWith(String keyword) {
95	0	return associatedWith.contains(keyword);
96		}
97
98		@Override
99		public boolean equals(Object o) {
100	0	if (this == o)
101	0	return true;
102	0	if (o == null \|\| getClass() != o.getClass())
103	0	return false;
104
105	0	Index index = (Index) o;
106	0	boolean equals = true;
107	0	for (String column : index.getColumns()) {
108	0	if (!columns.contains(column)) {
109	0	equals = false;
110		}
111		}
112
113	0	if (this.unique == null && index.isUnique() == null) {
114		// continue check
115	0	} else if (this.unique == null && index.isUnique() != null) {
116	0	equals = false;
117	0	} else if (this.unique != null && index.isUnique() == null) {
118	0	equals = false;
119	0	} else if (!this.unique.equals(index.isUnique())) {
120	0	equals = false;
121		}
122
123	0	return equals \|\| table.getName().equalsIgnoreCase(index.table.getName());
124
125		}
126
127		@Override
128		public int hashCode() {
129		int result;
130	0	result = table.getName().toUpperCase().hashCode();
131	0	result = 31 * result + columns.hashCode();
132	0	result = 31 * result + (unique == null ? 2 : unique ? 1 : 0);
133	0	return result;
134		}
135
136		@Override
137		public int compareTo(Index o) {
138	0	int returnValue = this.table.getName().compareTo(o.table.getName());
139
140	0	if (returnValue == 0) {
141	0	String thisName = StringUtils.trimToEmpty(this.getName());
142	0	String oName = StringUtils.trimToEmpty(o.getName());
143	0	returnValue = thisName.compareTo(oName);
144		}
145
146		// We should not have two indexes that have the same name and tablename
147		/*
148		* if (returnValue == 0) { returnValue = this.getColumnName().compareTo(o.getColumnName()); }
149		*/
150
151	0	return returnValue;
152		}
153
154		@Override
155		public String toString() {
156	0	StringBuffer stringBuffer = new StringBuffer();
157	0	stringBuffer.append(getName());
158	0	if (this.unique != null && !this.unique) {
159	0	stringBuffer.append(" unique ");
160		}
161	0	if (table != null && columns != null) {
162	0	stringBuffer.append(" on ").append(table.getName());
163	0	if (columns != null) {
164	0	stringBuffer.append("(");
165	0	for (String column : columns) {
166	0	stringBuffer.append(column).append(", ");
167		}
168	0	stringBuffer.delete(stringBuffer.length() - 2, stringBuffer.length());
169	0	stringBuffer.append(")");
170		}
171		}
172	0	return stringBuffer.toString();
173		}
174		}