Coverage Report

Coverage Report - liquibase.snapshot.DatabaseSnapshot

Classes in this File

Line Coverage

Branch Coverage

Complexity

DatabaseSnapshot

0/76

0/54

2.385

 package liquibase.snapshot;
 
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.Set;
 
 import liquibase.database.Database;
 import liquibase.database.structure.Column;
 import liquibase.database.structure.ForeignKey;
 import liquibase.database.structure.Index;
 import liquibase.database.structure.PrimaryKey;
 import liquibase.database.structure.Sequence;
 import liquibase.database.structure.Table;
 import liquibase.database.structure.UniqueConstraint;
 import liquibase.database.structure.View;
 import liquibase.util.StringUtils;
 
 public class DatabaseSnapshot {
 
     private Database database;
     private Set<Table> tables = new HashSet<Table>();
     private Set<View> views = new HashSet<View>();
     private Set<ForeignKey> foreignKeys = new HashSet<ForeignKey>();
     private Set<UniqueConstraint> uniqueConstraints = new HashSet<UniqueConstraint>();
     private Set<Index> indexes = new HashSet<Index>();
     private Set<PrimaryKey> primaryKeys = new HashSet<PrimaryKey>();
     private Set<Sequence> sequences = new HashSet<Sequence>();
 
     private String schema;
 
     private Table databaseChangeLogTable;
     private Table databaseChangeLogLockTable;
 
     public DatabaseSnapshot(Database database, String requestedSchema) {
         this.database = database;
         this.schema = requestedSchema;
     }
 
     public Database getDatabase() {
         return database;
     }
 
     public Set<Table> getTables() {
         return tables;
     }
 
     public Set<View> getViews() {
         return views;
     }
 
     public Set<ForeignKey> getForeignKeys() {
         return foreignKeys;
     }
 
     public Set<Index> getIndexes() {
         return indexes;
     }
 
     public Set<PrimaryKey> getPrimaryKeys() {
         return primaryKeys;
     }
 
     public Set<Sequence> getSequences() {
         return sequences;
     }
 
     public Set<UniqueConstraint> getUniqueConstraints() {
         return this.uniqueConstraints;
     }
 
     public Table getTable(String tableName) {
         for (Table table : getTables()) {
             if (table.getName().equalsIgnoreCase(tableName)) {
                 return table;
             }
         }
         return null;
     }
 
     public ForeignKey getForeignKey(String foreignKeyName) {
         for (ForeignKey fk : getForeignKeys()) {
             if (fk.getName().equalsIgnoreCase(foreignKeyName)) {
                 return fk;
             }
         }
         return null;
     }
 
     public Sequence getSequence(String sequenceName) {
         for (Sequence sequence : getSequences()) {
             if (sequence.getName().equalsIgnoreCase(sequenceName)) {
                 return sequence;
             }
         }
         return null;
     }
 
     public Index getIndex(String indexName) {
         for (Index index : getIndexes()) {
             if (StringUtils.trimToEmpty(index.getName()).equalsIgnoreCase(indexName)) {
                 return index;
             }
         }
         return null;
     }
 
     public View getView(String viewName) {
         for (View view : getViews()) {
             if (view.getName().equalsIgnoreCase(viewName)) {
                 return view;
             }
         }
         return null;
     }
 
     public PrimaryKey getPrimaryKey(String pkName) {
         for (PrimaryKey pk : getPrimaryKeys()) {
             if (pk.getName().equalsIgnoreCase(pkName)) {
                 return pk;
             }
         }
         return null;
     }
 
     public PrimaryKey getPrimaryKeyForTable(String tableName) {
         for (PrimaryKey pk : getPrimaryKeys()) {
             if (pk.getTable().getName().equalsIgnoreCase(tableName)) {
                 return pk;
             }
         }
         return null;
     }
 
     public UniqueConstraint getUniqueConstraint(String ucName) {
         for (UniqueConstraint uc : getUniqueConstraints()) {
             if (uc.getName().equalsIgnoreCase(ucName)) {
                 return uc;
             }
         }
         return null;
     }
 
     public String getSchema() {
         return schema;
     }
 
     public boolean isPrimaryKey(Column columnInfo) {
         for (PrimaryKey pk : getPrimaryKeys()) {
             if (columnInfo.getTable() == null) {
                 continue;
             }
             if (pk.getTable().getName().equalsIgnoreCase(columnInfo.getTable().getName())) {
                 if (pk.getColumnNamesAsList().contains(columnInfo.getName())) {
                     return true;
                 }
             }
         }
 
         return false;
     }
 
     public Collection<Column> getColumns() {
         Set<Column> returnSet = new HashSet<Column>();
 
         for (Table table : getTables()) {
             for (Column column : table.getColumns()) {
                 returnSet.add(column);
             }
         }
 
         return returnSet;
     }
 
     public Column getColumn(String tableName, String columnName) {
         for (Table table : getTables()) {
             for (Column column : table.getColumns()) {
                 if (table.getName().equalsIgnoreCase(tableName) && column.getName().equalsIgnoreCase(columnName)) {
                     return column;
                 }
             }
         }
         return null;
     }
 
     public boolean hasDatabaseChangeLogTable() {
         return databaseChangeLogTable != null;
     }
 
     public Table getDatabaseChangeLogTable() {
         return databaseChangeLogTable;
     }
 
     public void setDatabaseChangeLogTable(Table table) {
         this.databaseChangeLogTable = table;
     }
 
     public Table getDatabaseChangeLogLockTable() {
         return databaseChangeLogLockTable;
     }
 
     public void setDatabaseChangeLogLockTable(Table table) {
         this.databaseChangeLogLockTable = table;
     }
 }

1		package liquibase.snapshot;
2
3		import java.util.Collection;
4		import java.util.HashSet;
5		import java.util.Set;
6
7		import liquibase.database.Database;
8		import liquibase.database.structure.Column;
9		import liquibase.database.structure.ForeignKey;
10		import liquibase.database.structure.Index;
11		import liquibase.database.structure.PrimaryKey;
12		import liquibase.database.structure.Sequence;
13		import liquibase.database.structure.Table;
14		import liquibase.database.structure.UniqueConstraint;
15		import liquibase.database.structure.View;
16		import liquibase.util.StringUtils;
17
18		public class DatabaseSnapshot {
19
20		private Database database;
21	0	private Set<Table> tables = new HashSet<Table>();
22	0	private Set<View> views = new HashSet<View>();
23	0	private Set<ForeignKey> foreignKeys = new HashSet<ForeignKey>();
24	0	private Set<UniqueConstraint> uniqueConstraints = new HashSet<UniqueConstraint>();
25	0	private Set<Index> indexes = new HashSet<Index>();
26	0	private Set<PrimaryKey> primaryKeys = new HashSet<PrimaryKey>();
27	0	private Set<Sequence> sequences = new HashSet<Sequence>();
28
29		private String schema;
30
31		private Table databaseChangeLogTable;
32		private Table databaseChangeLogLockTable;
33
34	0	public DatabaseSnapshot(Database database, String requestedSchema) {
35	0	this.database = database;
36	0	this.schema = requestedSchema;
37	0	}
38
39		public Database getDatabase() {
40	0	return database;
41		}
42
43		public Set<Table> getTables() {
44	0	return tables;
45		}
46
47		public Set<View> getViews() {
48	0	return views;
49		}
50
51		public Set<ForeignKey> getForeignKeys() {
52	0	return foreignKeys;
53		}
54
55		public Set<Index> getIndexes() {
56	0	return indexes;
57		}
58
59		public Set<PrimaryKey> getPrimaryKeys() {
60	0	return primaryKeys;
61		}
62
63		public Set<Sequence> getSequences() {
64	0	return sequences;
65		}
66
67		public Set<UniqueConstraint> getUniqueConstraints() {
68	0	return this.uniqueConstraints;
69		}
70
71		public Table getTable(String tableName) {
72	0	for (Table table : getTables()) {
73	0	if (table.getName().equalsIgnoreCase(tableName)) {
74	0	return table;
75		}
76		}
77	0	return null;
78		}
79
80		public ForeignKey getForeignKey(String foreignKeyName) {
81	0	for (ForeignKey fk : getForeignKeys()) {
82	0	if (fk.getName().equalsIgnoreCase(foreignKeyName)) {
83	0	return fk;
84		}
85		}
86	0	return null;
87		}
88
89		public Sequence getSequence(String sequenceName) {
90	0	for (Sequence sequence : getSequences()) {
91	0	if (sequence.getName().equalsIgnoreCase(sequenceName)) {
92	0	return sequence;
93		}
94		}
95	0	return null;
96		}
97
98		public Index getIndex(String indexName) {
99	0	for (Index index : getIndexes()) {
100	0	if (StringUtils.trimToEmpty(index.getName()).equalsIgnoreCase(indexName)) {
101	0	return index;
102		}
103		}
104	0	return null;
105		}
106
107		public View getView(String viewName) {
108	0	for (View view : getViews()) {
109	0	if (view.getName().equalsIgnoreCase(viewName)) {
110	0	return view;
111		}
112		}
113	0	return null;
114		}
115
116		public PrimaryKey getPrimaryKey(String pkName) {
117	0	for (PrimaryKey pk : getPrimaryKeys()) {
118	0	if (pk.getName().equalsIgnoreCase(pkName)) {
119	0	return pk;
120		}
121		}
122	0	return null;
123		}
124
125		public PrimaryKey getPrimaryKeyForTable(String tableName) {
126	0	for (PrimaryKey pk : getPrimaryKeys()) {
127	0	if (pk.getTable().getName().equalsIgnoreCase(tableName)) {
128	0	return pk;
129		}
130		}
131	0	return null;
132		}
133
134		public UniqueConstraint getUniqueConstraint(String ucName) {
135	0	for (UniqueConstraint uc : getUniqueConstraints()) {
136	0	if (uc.getName().equalsIgnoreCase(ucName)) {
137	0	return uc;
138		}
139		}
140	0	return null;
141		}
142
143		public String getSchema() {
144	0	return schema;
145		}
146
147		public boolean isPrimaryKey(Column columnInfo) {
148	0	for (PrimaryKey pk : getPrimaryKeys()) {
149	0	if (columnInfo.getTable() == null) {
150	0	continue;
151		}
152	0	if (pk.getTable().getName().equalsIgnoreCase(columnInfo.getTable().getName())) {
153	0	if (pk.getColumnNamesAsList().contains(columnInfo.getName())) {
154	0	return true;
155		}
156		}
157		}
158
159	0	return false;
160		}
161
162		public Collection<Column> getColumns() {
163	0	Set<Column> returnSet = new HashSet<Column>();
164
165	0	for (Table table : getTables()) {
166	0	for (Column column : table.getColumns()) {
167	0	returnSet.add(column);
168		}
169		}
170
171	0	return returnSet;
172		}
173
174		public Column getColumn(String tableName, String columnName) {
175	0	for (Table table : getTables()) {
176	0	for (Column column : table.getColumns()) {
177	0	if (table.getName().equalsIgnoreCase(tableName) && column.getName().equalsIgnoreCase(columnName)) {
178	0	return column;
179		}
180		}
181		}
182	0	return null;
183		}
184
185		public boolean hasDatabaseChangeLogTable() {
186	0	return databaseChangeLogTable != null;
187		}
188
189		public Table getDatabaseChangeLogTable() {
190	0	return databaseChangeLogTable;
191		}
192
193		public void setDatabaseChangeLogTable(Table table) {
194	0	this.databaseChangeLogTable = table;
195	0	}
196
197		public Table getDatabaseChangeLogLockTable() {
198	0	return databaseChangeLogLockTable;
199		}
200
201		public void setDatabaseChangeLogLockTable(Table table) {
202	0	this.databaseChangeLogLockTable = table;
203	0	}
204		}