Coverage Report

Coverage Report - liquibase.snapshot.jvm.SQLiteDatabaseSnapshotGenerator

Classes in this File

Line Coverage

Branch Coverage

Complexity

SQLiteDatabaseSnapshotGenerator

0/242

0/106

7.182

 package liquibase.snapshot.jvm;
 
 import java.sql.DatabaseMetaData;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.sql.Statement;
 import java.text.ParseException;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
 
 import liquibase.database.Database;
 import liquibase.database.core.SQLiteDatabase;
 import liquibase.database.jvm.JdbcConnection;
 import liquibase.database.structure.Column;
 import liquibase.database.structure.Index;
 import liquibase.database.structure.PrimaryKey;
 import liquibase.database.structure.Sequence;
 import liquibase.database.structure.Table;
 import liquibase.database.structure.View;
 import liquibase.database.typeconversion.TypeConverterFactory;
 import liquibase.exception.DatabaseException;
 import liquibase.executor.ExecutorService;
 import liquibase.logging.LogFactory;
 import liquibase.snapshot.DatabaseSnapshot;
 import liquibase.statement.core.GetViewDefinitionStatement;
 import liquibase.statement.core.SelectSequencesStatement;
 import liquibase.util.StringUtils;
 
 public class SQLiteDatabaseSnapshotGenerator extends JdbcDatabaseSnapshotGenerator {
 
     /**
      * Creates an empty database snapshot
      */
     public SQLiteDatabaseSnapshotGenerator() {
     }
 
     @Override
     public boolean supports(Database database) {
         return database instanceof SQLiteDatabase;
     }
 
     @Override
     public int getPriority(Database database) {
         return PRIORITY_DATABASE;
     }
 
     @Override
     protected void readTables(DatabaseSnapshot snapshot, String schema, DatabaseMetaData databaseMetaData)
             throws SQLException, DatabaseException {
 
         Database database = snapshot.getDatabase();
 
         updateListeners("Reading tables for " + database.toString() + " ...");
         ResultSet rs = databaseMetaData.getTables(database.convertRequestedSchemaToCatalog(schema),
                 database.convertRequestedSchemaToSchema(schema), null, new String[] { "TABLE", "VIEW" });
 
         try {
             while (rs.next()) {
                 String type = rs.getString("TABLE_TYPE");
                 String name = rs.getString("TABLE_NAME");
                 String schemaName = rs.getString("TABLE_SCHEM");
                 String catalogName = rs.getString("TABLE_CAT");
                 String remarks = rs.getString("REMARKS");
 
                 if (database.isSystemTable(catalogName, schemaName, name) || database.isLiquibaseTable(name)
                         || database.isSystemView(catalogName, schemaName, name)) {
                     continue;
                 }
 
                 if ("TABLE".equals(type)) {
                     Table table = new Table(name);
                     table.setRemarks(StringUtils.trimToNull(remarks));
                     table.setDatabase(database);
                     table.setSchema(schemaName);
                     snapshot.getTables().add(table);
                 } else if ("VIEW".equals(type)) {
                     View view = new View();
                     view.setName(name);
                     view.setSchema(schemaName);
                     try {
                         view.setDefinition(database.getViewDefinition(schema, name));
                     } catch (DatabaseException e) {
                         System.out.println("Error getting view with " + new GetViewDefinitionStatement(schema, name));
                         throw e;
                     }
                     snapshot.getViews().add(view);
                 }
             }
         } finally {
             rs.close();
         }
     }
 
     @Override
     protected void readViews(DatabaseSnapshot snapshot, String schema, DatabaseMetaData databaseMetaData)
             throws SQLException, DatabaseException {
 
         Database database = snapshot.getDatabase();
 
         updateListeners("Reading tables for " + database.toString() + " ...");
         ResultSet rs = databaseMetaData.getTables(database.convertRequestedSchemaToCatalog(schema),
                 database.convertRequestedSchemaToSchema(schema), null, new String[] { "TABLE", "VIEW" });
 
         try {
             while (rs.next()) {
                 String type = rs.getString("TABLE_TYPE");
                 String name = rs.getString("TABLE_NAME");
                 String schemaName = rs.getString("TABLE_SCHEM");
                 String catalogName = rs.getString("TABLE_CAT");
                 String remarks = rs.getString("REMARKS");
 
                 if (database.isSystemTable(catalogName, schemaName, name) || database.isLiquibaseTable(name)
                         || database.isSystemView(catalogName, schemaName, name)) {
                     continue;
                 }
 
                 if ("TABLE".equals(type)) {
                     Table table = new Table(name);
                     table.setRemarks(StringUtils.trimToNull(remarks));
                     table.setDatabase(database);
                     table.setSchema(schemaName);
                     snapshot.getTables().add(table);
                 } else if ("VIEW".equals(type)) {
                     View view = new View();
                     view.setName(name);
                     view.setSchema(schemaName);
                     try {
                         view.setDefinition(database.getViewDefinition(schema, name));
                     } catch (DatabaseException e) {
                         System.out.println("Error getting view with " + new GetViewDefinitionStatement(schema, name));
                         throw e;
                     }
                     snapshot.getViews().add(view);
                 }
             }
         } finally {
             rs.close();
         }
     }
 
     /**
      * SQLite specific implementation
      */
     @Override
     protected void readForeignKeyInformation(DatabaseSnapshot snapshot, String schema, DatabaseMetaData databaseMetaData)
             throws DatabaseException, SQLException {
         updateListeners("Reading foreign keys for " + snapshot.getDatabase().toString() + " ...");
         // Foreign keys are not supported in SQLite until now.
         // ...do nothing here
     }
 
     /**
      * SQLite specific implementation
      */
     @Override
     protected void readPrimaryKeys(DatabaseSnapshot snapshot, String schema, DatabaseMetaData databaseMetaData)
             throws DatabaseException, SQLException {
         Database database = snapshot.getDatabase();
         updateListeners("Reading primary keys for " + database.toString() + " ...");
 
         // we can't add directly to the this.primaryKeys hashSet because adding columns to an exising PK changes the
         // hashCode and .contains() fails
         List<PrimaryKey> foundPKs = new ArrayList<PrimaryKey>();
 
         for (Table table : snapshot.getTables()) {
             ResultSet rs = databaseMetaData.getPrimaryKeys(database.convertRequestedSchemaToCatalog(schema),
                     database.convertRequestedSchemaToSchema(schema), table.getName());
 
             try {
                 while (rs.next()) {
                     String tableName = rs.getString("TABLE_NAME");
                     String columnName = rs.getString("COLUMN_NAME");
                     short position = rs.getShort("KEY_SEQ");
 
                     if (!(database instanceof SQLiteDatabase)) {
                         position -= 1;
                     }
 
                     boolean foundExistingPK = false;
                     for (PrimaryKey pk : foundPKs) {
                         if (pk.getTable().getName().equals(tableName)) {
                             pk.addColumnName(position, columnName);
 
                             foundExistingPK = true;
                         }
                     }
 
                     if (!foundExistingPK) {
                         PrimaryKey primaryKey = new PrimaryKey();
                         primaryKey.setTable(table);
                         primaryKey.addColumnName(position, columnName);
                         primaryKey.setName(rs.getString("PK_NAME"));
 
                         foundPKs.add(primaryKey);
                     }
                 }
             } finally {
                 rs.close();
             }
 
         }
 
         snapshot.getPrimaryKeys().addAll(foundPKs);
     }
 
     @Override
     protected void readColumns(DatabaseSnapshot snapshot, String schema, DatabaseMetaData databaseMetaData)
             throws SQLException, DatabaseException {
         Database database = snapshot.getDatabase();
         updateListeners("Reading columns for " + database.toString() + " ...");
 
         if (database instanceof SQLiteDatabase) {
             // ...work around for SQLite
             for (Table cur_table : snapshot.getTables()) {
                 Statement selectStatement = null;
                 ResultSet rs = null;
                 try {
                     selectStatement = ((JdbcConnection) database.getConnection()).getUnderlyingConnection()
                             .createStatement();
                     rs = databaseMetaData.getColumns(database.convertRequestedSchemaToCatalog(schema),
                             database.convertRequestedSchemaToSchema(schema), cur_table.getName(), null);
                     if (rs == null) {
                         rs = databaseMetaData.getColumns(database.convertRequestedSchemaToCatalog(schema),
                                 database.convertRequestedSchemaToSchema(schema), cur_table.getName(), null);
                     }
                     while ((rs != null) && rs.next()) {
                         readColumnInfo(snapshot, schema, rs);
                     }
                 } finally {
                     if (rs != null) {
                         try {
                             rs.close();
                         } catch (SQLException ignored) {
                         }
                     }
                     if (selectStatement != null) {
                         selectStatement.close();
                     }
                 }
             }
         } else {
             // ...if it is no SQLite database
             Statement selectStatement = null;
             ResultSet rs = null;
             try {
                 selectStatement = ((JdbcConnection) database.getConnection()).getUnderlyingConnection()
                         .createStatement();
                 rs = databaseMetaData.getColumns(database.convertRequestedSchemaToCatalog(schema),
                         database.convertRequestedSchemaToSchema(schema), null, null);
                 while (rs.next()) {
                     readColumnInfo(snapshot, schema, rs);
                 }
             } finally {
                 if (rs != null) {
                     try {
                         rs.close();
                     } catch (SQLException ignored) {
                     }
                 }
                 if (selectStatement != null) {
                     selectStatement.close();
                 }
             }
         }
     }
 
     private Column readColumnInfo(DatabaseSnapshot snapshot, String schema, ResultSet rs) throws SQLException,
             DatabaseException {
         Database database = snapshot.getDatabase();
         Column columnInfo = new Column();
 
         String tableName = rs.getString("TABLE_NAME");
         String columnName = rs.getString("COLUMN_NAME");
         String schemaName = rs.getString("TABLE_SCHEM");
         String catalogName = rs.getString("TABLE_CAT");
 
         String upperCaseTableName = tableName.toUpperCase(Locale.ENGLISH);
 
         if (database.isSystemTable(catalogName, schemaName, upperCaseTableName)
                 || database.isLiquibaseTable(upperCaseTableName)) {
             return null;
         }
 
         Table table = snapshot.getTable(tableName);
         if (table == null) {
             View view = snapshot.getView(tableName);
             if (view == null) {
                 LogFactory.getLogger().debug("Could not find table or view " + tableName + " for column " + columnName);
                 return null;
             } else {
                 columnInfo.setView(view);
                 view.getColumns().add(columnInfo);
             }
         } else {
             columnInfo.setTable(table);
             table.getColumns().add(columnInfo);
         }
 
         columnInfo.setName(columnName);
         columnInfo.setDataType(rs.getInt("DATA_TYPE"));
         columnInfo.setColumnSize(rs.getInt("COLUMN_SIZE"));
         columnInfo.setDecimalDigits(rs.getInt("DECIMAL_POINTS"));
         Object defaultValue = rs.getObject("COLUMN_DEF");
         try {
             columnInfo.setDefaultValue(TypeConverterFactory
                     .getInstance()
                     .findTypeConverter(database)
                     .convertDatabaseValueToObject(defaultValue, columnInfo.getDataType(), columnInfo.getColumnSize(),
                             columnInfo.getDecimalDigits(), database));
         } catch (ParseException e) {
             throw new DatabaseException(e);
         }
 
         int nullable = rs.getInt("NULLABLE");
         if (nullable == DatabaseMetaData.columnNoNulls) {
             columnInfo.setNullable(false);
         } else if (nullable == DatabaseMetaData.columnNullable) {
             columnInfo.setNullable(true);
         }
 
         columnInfo.setPrimaryKey(snapshot.isPrimaryKey(columnInfo));
         columnInfo.setAutoIncrement(isColumnAutoIncrement(database, schema, tableName, columnName));
         columnInfo.setTypeName(TypeConverterFactory.getInstance().findTypeConverter(database)
                 .getDataType(rs.getString("TYPE_NAME"), columnInfo.isAutoIncrement()).toString());
 
         return columnInfo;
     }
 
     @Override
     protected void readIndexes(DatabaseSnapshot snapshot, String schema, DatabaseMetaData databaseMetaData)
             throws DatabaseException, SQLException {
         Database database = snapshot.getDatabase();
         updateListeners("Reading indexes for " + database.toString() + " ...");
 
         for (Table table : snapshot.getTables()) {
             ResultSet rs = null;
             Statement statement = null;
             Map<String, Index> indexMap;
             try {
                 indexMap = new HashMap<String, Index>();
 
                 // for the odbc driver at http://www.ch-werner.de/sqliteodbc/
                 // databaseMetaData.getIndexInfo is not implemented
                 statement = ((JdbcConnection) database.getConnection()).getUnderlyingConnection().createStatement();
                 String sql = "PRAGMA index_list(" + table.getName() + ");";
                 try {
                     rs = statement.executeQuery(sql);
                 } catch (SQLException e) {
                     if (!e.getMessage().equals("query does not return ResultSet")) {
                         System.err.println(e);
                         // throw e;
                     }
                 }
                 while ((rs != null) && rs.next()) {
                     String index_name = rs.getString("name");
                     boolean index_unique = rs.getBoolean("unique");
                     sql = "PRAGMA index_info(" + index_name + ");";
                     Statement statement_2 = null;
                     ResultSet rs_2 = null;
                     try {
                         statement_2 = ((JdbcConnection) database.getConnection()).getUnderlyingConnection()
                                 .createStatement();
                         rs_2 = statement_2.executeQuery(sql);
                         while ((rs_2 != null) && rs_2.next()) {
                             int index_column_seqno = rs_2.getInt("seqno");
                             // int index_column_cid = rs.getInt("cid");
                             String index_column_name = rs_2.getString("name");
                             if (index_unique) {
                                 Column column = snapshot.getColumn(table.getName(), index_column_name);
                                 column.setUnique(true);
                             } else {
                                 Index indexInformation;
                                 if (indexMap.containsKey(index_name)) {
                                     indexInformation = indexMap.get(index_name);
                                 } else {
                                     indexInformation = new Index();
                                     indexInformation.setTable(table);
                                     indexInformation.setName(index_name);
                                     indexInformation.setFilterCondition("");
                                     indexMap.put(index_name, indexInformation);
                                 }
                                 indexInformation.getColumns().add(index_column_seqno, index_column_name);
                             }
                         }
                     } finally {
                         if (rs_2 != null) {
                             try {
                                 rs_2.close();
                             } catch (SQLException ignored) {
                             }
                         }
                         if (statement_2 != null) {
                             try {
                                 statement_2.close();
                             } catch (SQLException ignored) {
                             }
                         }
                     }
 
                 }
             } finally {
                 if (rs != null) {
                     try {
                         rs.close();
                     } catch (SQLException ignored) {
                     }
                 }
                 if (statement != null) {
                     try {
                         statement.close();
                     } catch (SQLException ignored) {
                     }
                 }
             }
 
             for (Map.Entry<String, Index> entry : indexMap.entrySet()) {
                 snapshot.getIndexes().add(entry.getValue());
             }
         }
 
         // remove PK indexes
         Set<Index> indexesToRemove = new HashSet<Index>();
         for (Index index : snapshot.getIndexes()) {
             for (PrimaryKey pk : snapshot.getPrimaryKeys()) {
                 if (index.getTable().getName().equalsIgnoreCase(pk.getTable().getName())
                         && index.getColumnNames().equals(pk.getColumnNames())) {
                     indexesToRemove.add(index);
                 }
             }
         }
         snapshot.getIndexes().removeAll(indexesToRemove);
     }
 
     @Override
     protected void readSequences(DatabaseSnapshot snapshot, String schema, DatabaseMetaData databaseMetaData)
             throws DatabaseException {
         Database database = snapshot.getDatabase();
         updateListeners("Reading sequences for " + database.toString() + " ...");
 
         String convertedSchemaName = database.convertRequestedSchemaToSchema(schema);
 
         if (database.supportsSequences()) {
             // noinspection unchecked
             List<String> sequenceNamess = (List<String>) ExecutorService.getInstance().getExecutor(database)
                     .queryForList(new SelectSequencesStatement(schema), String.class);
 
             for (String sequenceName : sequenceNamess) {
                 Sequence seq = new Sequence();
                 seq.setName(sequenceName.trim());
                 seq.setName(convertedSchemaName);
 
                 snapshot.getSequences().add(seq);
             }
         }
     }
 
 }

1		package liquibase.snapshot.jvm;
2
3		import java.sql.DatabaseMetaData;
4		import java.sql.ResultSet;
5		import java.sql.SQLException;
6		import java.sql.Statement;
7		import java.text.ParseException;
8		import java.util.ArrayList;
9		import java.util.HashMap;
10		import java.util.HashSet;
11		import java.util.List;
12		import java.util.Locale;
13		import java.util.Map;
14		import java.util.Set;
15
16		import liquibase.database.Database;
17		import liquibase.database.core.SQLiteDatabase;
18		import liquibase.database.jvm.JdbcConnection;
19		import liquibase.database.structure.Column;
20		import liquibase.database.structure.Index;
21		import liquibase.database.structure.PrimaryKey;
22		import liquibase.database.structure.Sequence;
23		import liquibase.database.structure.Table;
24		import liquibase.database.structure.View;
25		import liquibase.database.typeconversion.TypeConverterFactory;
26		import liquibase.exception.DatabaseException;
27		import liquibase.executor.ExecutorService;
28		import liquibase.logging.LogFactory;
29		import liquibase.snapshot.DatabaseSnapshot;
30		import liquibase.statement.core.GetViewDefinitionStatement;
31		import liquibase.statement.core.SelectSequencesStatement;
32		import liquibase.util.StringUtils;
33
34		public class SQLiteDatabaseSnapshotGenerator extends JdbcDatabaseSnapshotGenerator {
35
36		/**
37		* Creates an empty database snapshot
38		*/
39	0	public SQLiteDatabaseSnapshotGenerator() {
40	0	}
41
42		@Override
43		public boolean supports(Database database) {
44	0	return database instanceof SQLiteDatabase;
45		}
46
47		@Override
48		public int getPriority(Database database) {
49	0	return PRIORITY_DATABASE;
50		}
51
52		@Override
53		protected void readTables(DatabaseSnapshot snapshot, String schema, DatabaseMetaData databaseMetaData)
54		throws SQLException, DatabaseException {
55
56	0	Database database = snapshot.getDatabase();
57
58	0	updateListeners("Reading tables for " + database.toString() + " ...");
59	0	ResultSet rs = databaseMetaData.getTables(database.convertRequestedSchemaToCatalog(schema),
60		database.convertRequestedSchemaToSchema(schema), null, new String[] { "TABLE", "VIEW" });
61
62		try {
63	0	while (rs.next()) {
64	0	String type = rs.getString("TABLE_TYPE");
65	0	String name = rs.getString("TABLE_NAME");
66	0	String schemaName = rs.getString("TABLE_SCHEM");
67	0	String catalogName = rs.getString("TABLE_CAT");
68	0	String remarks = rs.getString("REMARKS");
69
70	0	if (database.isSystemTable(catalogName, schemaName, name) \|\| database.isLiquibaseTable(name)
71		\|\| database.isSystemView(catalogName, schemaName, name)) {
72	0	continue;
73		}
74
75	0	if ("TABLE".equals(type)) {
76	0	Table table = new Table(name);
77	0	table.setRemarks(StringUtils.trimToNull(remarks));
78	0	table.setDatabase(database);
79	0	table.setSchema(schemaName);
80	0	snapshot.getTables().add(table);
81	0	} else if ("VIEW".equals(type)) {
82	0	View view = new View();
83	0	view.setName(name);
84	0	view.setSchema(schemaName);
85		try {
86	0	view.setDefinition(database.getViewDefinition(schema, name));
87	0	} catch (DatabaseException e) {
88	0	System.out.println("Error getting view with " + new GetViewDefinitionStatement(schema, name));
89	0	throw e;
90	0	}
91	0	snapshot.getViews().add(view);
92		}
93	0	}
94		} finally {
95	0	rs.close();
96	0	}
97	0	}
98
99		@Override
100		protected void readViews(DatabaseSnapshot snapshot, String schema, DatabaseMetaData databaseMetaData)
101		throws SQLException, DatabaseException {
102
103	0	Database database = snapshot.getDatabase();
104
105	0	updateListeners("Reading tables for " + database.toString() + " ...");
106	0	ResultSet rs = databaseMetaData.getTables(database.convertRequestedSchemaToCatalog(schema),
107		database.convertRequestedSchemaToSchema(schema), null, new String[] { "TABLE", "VIEW" });
108
109		try {
110	0	while (rs.next()) {
111	0	String type = rs.getString("TABLE_TYPE");
112	0	String name = rs.getString("TABLE_NAME");
113	0	String schemaName = rs.getString("TABLE_SCHEM");
114	0	String catalogName = rs.getString("TABLE_CAT");
115	0	String remarks = rs.getString("REMARKS");
116
117	0	if (database.isSystemTable(catalogName, schemaName, name) \|\| database.isLiquibaseTable(name)
118		\|\| database.isSystemView(catalogName, schemaName, name)) {
119	0	continue;
120		}
121
122	0	if ("TABLE".equals(type)) {
123	0	Table table = new Table(name);
124	0	table.setRemarks(StringUtils.trimToNull(remarks));
125	0	table.setDatabase(database);
126	0	table.setSchema(schemaName);
127	0	snapshot.getTables().add(table);
128	0	} else if ("VIEW".equals(type)) {
129	0	View view = new View();
130	0	view.setName(name);
131	0	view.setSchema(schemaName);
132		try {
133	0	view.setDefinition(database.getViewDefinition(schema, name));
134	0	} catch (DatabaseException e) {
135	0	System.out.println("Error getting view with " + new GetViewDefinitionStatement(schema, name));
136	0	throw e;
137	0	}
138	0	snapshot.getViews().add(view);
139		}
140	0	}
141		} finally {
142	0	rs.close();
143	0	}
144	0	}
145
146		/**
147		* SQLite specific implementation
148		*/
149		@Override
150		protected void readForeignKeyInformation(DatabaseSnapshot snapshot, String schema, DatabaseMetaData databaseMetaData)
151		throws DatabaseException, SQLException {
152	0	updateListeners("Reading foreign keys for " + snapshot.getDatabase().toString() + " ...");
153		// Foreign keys are not supported in SQLite until now.
154		// ...do nothing here
155	0	}
156
157		/**
158		* SQLite specific implementation
159		*/
160		@Override
161		protected void readPrimaryKeys(DatabaseSnapshot snapshot, String schema, DatabaseMetaData databaseMetaData)
162		throws DatabaseException, SQLException {
163	0	Database database = snapshot.getDatabase();
164	0	updateListeners("Reading primary keys for " + database.toString() + " ...");
165
166		// we can't add directly to the this.primaryKeys hashSet because adding columns to an exising PK changes the
167		// hashCode and .contains() fails
168	0	List<PrimaryKey> foundPKs = new ArrayList<PrimaryKey>();
169
170	0	for (Table table : snapshot.getTables()) {
171	0	ResultSet rs = databaseMetaData.getPrimaryKeys(database.convertRequestedSchemaToCatalog(schema),
172		database.convertRequestedSchemaToSchema(schema), table.getName());
173
174		try {
175	0	while (rs.next()) {
176	0	String tableName = rs.getString("TABLE_NAME");
177	0	String columnName = rs.getString("COLUMN_NAME");
178	0	short position = rs.getShort("KEY_SEQ");
179
180	0	if (!(database instanceof SQLiteDatabase)) {
181	0	position -= 1;
182		}
183
184	0	boolean foundExistingPK = false;
185	0	for (PrimaryKey pk : foundPKs) {
186	0	if (pk.getTable().getName().equals(tableName)) {
187	0	pk.addColumnName(position, columnName);
188
189	0	foundExistingPK = true;
190		}
191		}
192
193	0	if (!foundExistingPK) {
194	0	PrimaryKey primaryKey = new PrimaryKey();
195	0	primaryKey.setTable(table);
196	0	primaryKey.addColumnName(position, columnName);
197	0	primaryKey.setName(rs.getString("PK_NAME"));
198
199	0	foundPKs.add(primaryKey);
200		}
201	0	}
202		} finally {
203	0	rs.close();
204	0	}
205
206	0	}
207
208	0	snapshot.getPrimaryKeys().addAll(foundPKs);
209	0	}
210
211		@Override
212		protected void readColumns(DatabaseSnapshot snapshot, String schema, DatabaseMetaData databaseMetaData)
213		throws SQLException, DatabaseException {
214	0	Database database = snapshot.getDatabase();
215	0	updateListeners("Reading columns for " + database.toString() + " ...");
216
217	0	if (database instanceof SQLiteDatabase) {
218		// ...work around for SQLite
219	0	for (Table cur_table : snapshot.getTables()) {
220	0	Statement selectStatement = null;
221	0	ResultSet rs = null;
222		try {
223	0	selectStatement = ((JdbcConnection) database.getConnection()).getUnderlyingConnection()
224		.createStatement();
225	0	rs = databaseMetaData.getColumns(database.convertRequestedSchemaToCatalog(schema),
226		database.convertRequestedSchemaToSchema(schema), cur_table.getName(), null);
227	0	if (rs == null) {
228	0	rs = databaseMetaData.getColumns(database.convertRequestedSchemaToCatalog(schema),
229		database.convertRequestedSchemaToSchema(schema), cur_table.getName(), null);
230		}
231	0	while ((rs != null) && rs.next()) {
232	0	readColumnInfo(snapshot, schema, rs);
233		}
234		} finally {
235	0	if (rs != null) {
236		try {
237	0	rs.close();
238	0	} catch (SQLException ignored) {
239	0	}
240		}
241	0	if (selectStatement != null) {
242	0	selectStatement.close();
243		}
244		}
245	0	}
246		} else {
247		// ...if it is no SQLite database
248	0	Statement selectStatement = null;
249	0	ResultSet rs = null;
250		try {
251	0	selectStatement = ((JdbcConnection) database.getConnection()).getUnderlyingConnection()
252		.createStatement();
253	0	rs = databaseMetaData.getColumns(database.convertRequestedSchemaToCatalog(schema),
254		database.convertRequestedSchemaToSchema(schema), null, null);
255	0	while (rs.next()) {
256	0	readColumnInfo(snapshot, schema, rs);
257		}
258		} finally {
259	0	if (rs != null) {
260		try {
261	0	rs.close();
262	0	} catch (SQLException ignored) {
263	0	}
264		}
265	0	if (selectStatement != null) {
266	0	selectStatement.close();
267		}
268		}
269		}
270	0	}
271
272		private Column readColumnInfo(DatabaseSnapshot snapshot, String schema, ResultSet rs) throws SQLException,
273		DatabaseException {
274	0	Database database = snapshot.getDatabase();
275	0	Column columnInfo = new Column();
276
277	0	String tableName = rs.getString("TABLE_NAME");
278	0	String columnName = rs.getString("COLUMN_NAME");
279	0	String schemaName = rs.getString("TABLE_SCHEM");
280	0	String catalogName = rs.getString("TABLE_CAT");
281
282	0	String upperCaseTableName = tableName.toUpperCase(Locale.ENGLISH);
283
284	0	if (database.isSystemTable(catalogName, schemaName, upperCaseTableName)
285		\|\| database.isLiquibaseTable(upperCaseTableName)) {
286	0	return null;
287		}
288
289	0	Table table = snapshot.getTable(tableName);
290	0	if (table == null) {
291	0	View view = snapshot.getView(tableName);
292	0	if (view == null) {
293	0	LogFactory.getLogger().debug("Could not find table or view " + tableName + " for column " + columnName);
294	0	return null;
295		} else {
296	0	columnInfo.setView(view);
297	0	view.getColumns().add(columnInfo);
298		}
299	0	} else {
300	0	columnInfo.setTable(table);
301	0	table.getColumns().add(columnInfo);
302		}
303
304	0	columnInfo.setName(columnName);
305	0	columnInfo.setDataType(rs.getInt("DATA_TYPE"));
306	0	columnInfo.setColumnSize(rs.getInt("COLUMN_SIZE"));
307	0	columnInfo.setDecimalDigits(rs.getInt("DECIMAL_POINTS"));
308	0	Object defaultValue = rs.getObject("COLUMN_DEF");
309		try {
310	0	columnInfo.setDefaultValue(TypeConverterFactory
311		.getInstance()
312		.findTypeConverter(database)
313		.convertDatabaseValueToObject(defaultValue, columnInfo.getDataType(), columnInfo.getColumnSize(),
314		columnInfo.getDecimalDigits(), database));
315	0	} catch (ParseException e) {
316	0	throw new DatabaseException(e);
317	0	}
318
319	0	int nullable = rs.getInt("NULLABLE");
320	0	if (nullable == DatabaseMetaData.columnNoNulls) {
321	0	columnInfo.setNullable(false);
322	0	} else if (nullable == DatabaseMetaData.columnNullable) {
323	0	columnInfo.setNullable(true);
324		}
325
326	0	columnInfo.setPrimaryKey(snapshot.isPrimaryKey(columnInfo));
327	0	columnInfo.setAutoIncrement(isColumnAutoIncrement(database, schema, tableName, columnName));
328	0	columnInfo.setTypeName(TypeConverterFactory.getInstance().findTypeConverter(database)
329		.getDataType(rs.getString("TYPE_NAME"), columnInfo.isAutoIncrement()).toString());
330
331	0	return columnInfo;
332		}
333
334		@Override
335		protected void readIndexes(DatabaseSnapshot snapshot, String schema, DatabaseMetaData databaseMetaData)
336		throws DatabaseException, SQLException {
337	0	Database database = snapshot.getDatabase();
338	0	updateListeners("Reading indexes for " + database.toString() + " ...");
339
340	0	for (Table table : snapshot.getTables()) {
341	0	ResultSet rs = null;
342	0	Statement statement = null;
343		Map<String, Index> indexMap;
344		try {
345	0	indexMap = new HashMap<String, Index>();
346
347		// for the odbc driver at http://www.ch-werner.de/sqliteodbc/
348		// databaseMetaData.getIndexInfo is not implemented
349	0	statement = ((JdbcConnection) database.getConnection()).getUnderlyingConnection().createStatement();
350	0	String sql = "PRAGMA index_list(" + table.getName() + ");";
351		try {
352	0	rs = statement.executeQuery(sql);
353	0	} catch (SQLException e) {
354	0	if (!e.getMessage().equals("query does not return ResultSet")) {
355	0	System.err.println(e);
356		// throw e;
357		}
358	0	}
359	0	while ((rs != null) && rs.next()) {
360	0	String index_name = rs.getString("name");
361	0	boolean index_unique = rs.getBoolean("unique");
362	0	sql = "PRAGMA index_info(" + index_name + ");";
363	0	Statement statement_2 = null;
364	0	ResultSet rs_2 = null;
365		try {
366	0	statement_2 = ((JdbcConnection) database.getConnection()).getUnderlyingConnection()
367		.createStatement();
368	0	rs_2 = statement_2.executeQuery(sql);
369	0	while ((rs_2 != null) && rs_2.next()) {
370	0	int index_column_seqno = rs_2.getInt("seqno");
371		// int index_column_cid = rs.getInt("cid");
372	0	String index_column_name = rs_2.getString("name");
373	0	if (index_unique) {
374	0	Column column = snapshot.getColumn(table.getName(), index_column_name);
375	0	column.setUnique(true);
376	0	} else {
377		Index indexInformation;
378	0	if (indexMap.containsKey(index_name)) {
379	0	indexInformation = indexMap.get(index_name);
380		} else {
381	0	indexInformation = new Index();
382	0	indexInformation.setTable(table);
383	0	indexInformation.setName(index_name);
384	0	indexInformation.setFilterCondition("");
385	0	indexMap.put(index_name, indexInformation);
386		}
387	0	indexInformation.getColumns().add(index_column_seqno, index_column_name);
388		}
389	0	}
390		} finally {
391	0	if (rs_2 != null) {
392		try {
393	0	rs_2.close();
394	0	} catch (SQLException ignored) {
395	0	}
396		}
397	0	if (statement_2 != null) {
398		try {
399	0	statement_2.close();
400	0	} catch (SQLException ignored) {
401	0	}
402		}
403		}
404
405	0	}
406		} finally {
407	0	if (rs != null) {
408		try {
409	0	rs.close();
410	0	} catch (SQLException ignored) {
411	0	}
412		}
413	0	if (statement != null) {
414		try {
415	0	statement.close();
416	0	} catch (SQLException ignored) {
417	0	}
418		}
419		}
420
421	0	for (Map.Entry<String, Index> entry : indexMap.entrySet()) {
422	0	snapshot.getIndexes().add(entry.getValue());
423		}
424	0	}
425
426		// remove PK indexes
427	0	Set<Index> indexesToRemove = new HashSet<Index>();
428	0	for (Index index : snapshot.getIndexes()) {
429	0	for (PrimaryKey pk : snapshot.getPrimaryKeys()) {
430	0	if (index.getTable().getName().equalsIgnoreCase(pk.getTable().getName())
431		&& index.getColumnNames().equals(pk.getColumnNames())) {
432	0	indexesToRemove.add(index);
433		}
434		}
435		}
436	0	snapshot.getIndexes().removeAll(indexesToRemove);
437	0	}
438
439		@Override
440		protected void readSequences(DatabaseSnapshot snapshot, String schema, DatabaseMetaData databaseMetaData)
441		throws DatabaseException {
442	0	Database database = snapshot.getDatabase();
443	0	updateListeners("Reading sequences for " + database.toString() + " ...");
444
445	0	String convertedSchemaName = database.convertRequestedSchemaToSchema(schema);
446
447	0	if (database.supportsSequences()) {
448		// noinspection unchecked
449	0	List<String> sequenceNamess = (List<String>) ExecutorService.getInstance().getExecutor(database)
450		.queryForList(new SelectSequencesStatement(schema), String.class);
451
452	0	for (String sequenceName : sequenceNamess) {
453	0	Sequence seq = new Sequence();
454	0	seq.setName(sequenceName.trim());
455	0	seq.setName(convertedSchemaName);
456
457	0	snapshot.getSequences().add(seq);
458	0	}
459		}
460	0	}
461
462		}