Autopsy  4.11.0
Graphical digital forensics platform for The Sleuth Kit and other tools.
SqliteEamDb.java
Go to the documentation of this file.
1 /*
2  * Central Repository
3  *
4  * Copyright 2015-2019 Basis Technology Corp.
5  * Contact: carrier <at> sleuthkit <dot> org
6  *
7  * Licensed under the Apache License, Version 2.0 (the "License");
8  * you may not use this file except in compliance with the License.
9  * You may obtain a copy of the License at
10  *
11  * http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing, software
14  * distributed under the License is distributed on an "AS IS" BASIS,
15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16  * See the License for the specific language governing permissions and
17  * limitations under the License.
18  */
19 package org.sleuthkit.autopsy.centralrepository.datamodel;
20 
21 import java.sql.Connection;
22 import java.sql.ResultSet;
23 import java.sql.SQLException;
24 import java.sql.Statement;
25 import java.util.Arrays;
26 import java.util.List;
27 import java.util.Set;
28 import java.util.concurrent.locks.ReentrantReadWriteLock;
29 import java.util.logging.Level;
30 import org.apache.commons.dbcp2.BasicDataSource;
32 import org.sleuthkit.datamodel.TskData;
35 
41 final class SqliteEamDb extends AbstractSqlEamDb {
42 
43  private final static Logger LOGGER = Logger.getLogger(SqliteEamDb.class.getName());
44 
45  private static SqliteEamDb instance;
46 
47  private BasicDataSource connectionPool = null;
48 
49  private final SqliteEamDbSettings dbSettings;
50 
51  // While the Sqlite database should only be used for single users, it is still
52  // possible for multiple threads to attempt to write to the database simultaneously.
53  private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock(true);
54 
63  public synchronized static SqliteEamDb getInstance() throws EamDbException {
64  if (instance == null) {
65  instance = new SqliteEamDb();
66  }
67 
68  return instance;
69  }
70 
77  private SqliteEamDb() throws EamDbException {
78  dbSettings = new SqliteEamDbSettings();
79  bulkArtifactsThreshold = dbSettings.getBulkThreshold();
80  }
81 
82  @Override
83  public void shutdownConnections() throws EamDbException {
84  try {
85  synchronized (this) {
86  if (null != connectionPool) {
87  connectionPool.close();
88  connectionPool = null; // force it to be re-created on next connect()
89  }
90  clearCaches();
91  }
92  } catch (SQLException ex) {
93  throw new EamDbException("Failed to close existing database connections.", ex); // NON-NLS
94  }
95  }
96 
97  @Override
98  public void updateSettings() {
99  synchronized (this) {
100  dbSettings.loadSettings();
101  bulkArtifactsThreshold = dbSettings.getBulkThreshold();
102  }
103  }
104 
105  @Override
106  public void saveSettings() {
107  synchronized (this) {
108  dbSettings.saveSettings();
109  }
110  }
111 
112  @Override
113  public void reset() throws EamDbException {
114  try {
115  acquireExclusiveLock();
116 
117  Connection conn = connect();
118 
119  try {
120 
121  Statement dropContent = conn.createStatement();
122  dropContent.executeUpdate("DELETE FROM organizations");
123  dropContent.executeUpdate("DELETE FROM cases");
124  dropContent.executeUpdate("DELETE FROM data_sources");
125  dropContent.executeUpdate("DELETE FROM reference_sets");
126  dropContent.executeUpdate("DELETE FROM artifact_types");
127  dropContent.executeUpdate("DELETE FROM db_info");
128 
129  String instancesTemplate = "DELETE FROM %s_instances";
130  String referencesTemplate = "DELETE FROM global_files";
131  for (CorrelationAttributeInstance.Type type : defaultCorrelationTypes) {
132  dropContent.executeUpdate(String.format(instancesTemplate, type.getDbTableName()));
133  // FUTURE: support other reference types
134  if (type.getId() == CorrelationAttributeInstance.FILES_TYPE_ID) {
135  dropContent.executeUpdate(String.format(referencesTemplate, type.getDbTableName()));
136  }
137  }
138 
139  dropContent.executeUpdate("VACUUM");
140  } catch (SQLException ex) {
141  LOGGER.log(Level.WARNING, "Failed to reset database.", ex);
142  } finally {
143  EamDbUtil.closeConnection(conn);
144  }
145 
146  dbSettings.insertDefaultDatabaseContent();
147  } finally {
148  releaseExclusiveLock();
149  }
150  }
151 
156  private void setupConnectionPool(boolean foreignKeysEnabled) throws EamDbException {
157 
158  if (dbSettings.dbFileExists() == false) {
159  throw new EamDbException("Central repository database missing");
160  }
161 
162  connectionPool = new BasicDataSource();
163  connectionPool.setDriverClassName(dbSettings.getDriver());
164  connectionPool.setUrl(dbSettings.getConnectionURL());
165 
166  // tweak pool configuration
167  connectionPool.setInitialSize(50);
168  connectionPool.setMaxTotal(-1);
169  connectionPool.setMaxIdle(-1);
170  connectionPool.setMaxWaitMillis(1000);
171  connectionPool.setValidationQuery(dbSettings.getValidationQuery());
172  if (foreignKeysEnabled) {
173  connectionPool.setConnectionInitSqls(Arrays.asList("PRAGMA foreign_keys = ON"));
174  } else {
175  connectionPool.setConnectionInitSqls(Arrays.asList("PRAGMA foreign_keys = OFF"));
176  }
177  }
178 
188  @Override
189  protected Connection connect(boolean foreignKeys) throws EamDbException {
190  synchronized (this) {
191  if (!EamDb.isEnabled()) {
192  throw new EamDbException("Central Repository module is not enabled"); // NON-NLS
193  }
194  if (connectionPool == null) {
195  setupConnectionPool(foreignKeys);
196  }
197  try {
198  return connectionPool.getConnection();
199  } catch (SQLException ex) {
200  throw new EamDbException("Error getting connection from connection pool.", ex); // NON-NLS
201  }
202  }
203  }
204 
212  @Override
213  protected Connection connect() throws EamDbException {
214  return connect(true);
215  }
216 
217  @Override
218  protected String getConflictClause() {
219  // For sqlite, our conflict clause is part of the table schema
220  return "";
221  }
222 
231  @Override
232  public void newDbInfo(String name, String value) throws EamDbException {
233  try {
234  acquireExclusiveLock();
235  super.newDbInfo(name, value);
236  } finally {
237  releaseExclusiveLock();
238  }
239  }
240 
250  @Override
251  public String getDbInfo(String name) throws EamDbException {
252  try {
253  acquireSharedLock();
254  return super.getDbInfo(name);
255  } finally {
256  releaseSharedLock();
257  }
258  }
259 
268  @Override
269  public void updateDbInfo(String name, String value) throws EamDbException {
270  try {
271  acquireExclusiveLock();
272  super.updateDbInfo(name, value);
273  } finally {
274  releaseExclusiveLock();
275  }
276  }
277 
283  @Override
284  public CorrelationCase newCase(Case autopsyCase) throws EamDbException {
285  try {
286  acquireExclusiveLock();
287  return super.newCase(autopsyCase);
288  } finally {
289  releaseExclusiveLock();
290  }
291  }
292 
293  @Override
294  public void addDataSourceObjectId(int rowId, long dataSourceObjectId) throws EamDbException {
295  try {
296  acquireExclusiveLock();
297  super.addDataSourceObjectId(rowId, dataSourceObjectId);
298  } finally {
299  releaseExclusiveLock();
300  }
301  }
302 
310  @Override
311  public CorrelationCase newCase(CorrelationCase eamCase) throws EamDbException {
312  try {
313  acquireExclusiveLock();
314  return super.newCase(eamCase);
315  } finally {
316  releaseExclusiveLock();
317  }
318  }
319 
325  @Override
326  public void updateCase(CorrelationCase eamCase) throws EamDbException {
327  try {
328  acquireExclusiveLock();
329  super.updateCase(eamCase);
330  } finally {
331  releaseExclusiveLock();
332  }
333  }
334 
342  @Override
343  public CorrelationCase getCaseByUUID(String caseUUID) throws EamDbException {
344  try {
345  acquireSharedLock();
346  return super.getCaseByUUID(caseUUID);
347  } finally {
348  releaseSharedLock();
349  }
350  }
351 
359  @Override
360  public CorrelationCase getCaseById(int caseId) throws EamDbException {
361  try {
362  acquireSharedLock();
363  return super.getCaseById(caseId);
364  } finally {
365  releaseSharedLock();
366  }
367 
368  }
369 
375  @Override
376  public List<CorrelationCase> getCases() throws EamDbException {
377  try {
378  acquireSharedLock();
379  return super.getCases();
380  } finally {
381  releaseSharedLock();
382  }
383  }
384 
390  @Override
391  public CorrelationDataSource newDataSource(CorrelationDataSource eamDataSource) throws EamDbException {
392  try {
393  acquireExclusiveLock();
394  return super.newDataSource(eamDataSource);
395  } finally {
396  releaseExclusiveLock();
397  }
398  }
399 
409  @Override
410  public CorrelationDataSource getDataSource(CorrelationCase correlationCase, Long caseDbDataSourceId) throws EamDbException {
411  try {
412  acquireSharedLock();
413  return super.getDataSource(correlationCase, caseDbDataSourceId);
414  } finally {
415  releaseSharedLock();
416  }
417  }
418 
428  @Override
429  public CorrelationDataSource getDataSourceById(CorrelationCase correlationCase, int dataSourceId) throws EamDbException {
430  try {
431  acquireSharedLock();
432  return super.getDataSourceById(correlationCase, dataSourceId);
433  } finally {
434  releaseSharedLock();
435  }
436  }
437 
443  @Override
444  public List<CorrelationDataSource> getDataSources() throws EamDbException {
445  try {
446  acquireSharedLock();
447  return super.getDataSources();
448  } finally {
449  releaseSharedLock();
450  }
451  }
452 
461  @Override
462  public void updateDataSourceName(CorrelationDataSource eamDataSource, String newName) throws EamDbException {
463  try {
464  acquireExclusiveLock();
465  super.updateDataSourceName(eamDataSource, newName);
466  } finally {
467  releaseExclusiveLock();
468  }
469  }
470 
476  @Override
477  public void updateDataSourceMd5Hash(CorrelationDataSource eamDataSource) throws EamDbException {
478  try {
479  acquireExclusiveLock();
480  super.updateDataSourceMd5Hash(eamDataSource);
481  } finally {
482  releaseExclusiveLock();
483  }
484  }
485 
491  @Override
492  public void updateDataSourceSha1Hash(CorrelationDataSource eamDataSource) throws EamDbException {
493  try {
494  acquireExclusiveLock();
495  super.updateDataSourceSha1Hash(eamDataSource);
496  } finally {
497  releaseExclusiveLock();
498  }
499  }
500 
507  @Override
508  public void updateDataSourceSha256Hash(CorrelationDataSource eamDataSource) throws EamDbException {
509  try {
510  acquireExclusiveLock();
511  super.updateDataSourceSha256Hash(eamDataSource);
512  } finally {
513  releaseExclusiveLock();
514  }
515  }
516 
523  @Override
524  public void addArtifactInstance(CorrelationAttributeInstance eamArtifact) throws EamDbException {
525  try {
526  acquireExclusiveLock();
527  super.addArtifactInstance(eamArtifact);
528  } finally {
529  releaseExclusiveLock();
530  }
531  }
532 
533  @Override
534  public List<CorrelationAttributeInstance> getArtifactInstancesByTypeValue(CorrelationAttributeInstance.Type aType, String value) throws EamDbException, CorrelationAttributeNormalizationException {
535  try {
536  acquireSharedLock();
537  return super.getArtifactInstancesByTypeValue(aType, value);
538  } finally {
539  releaseSharedLock();
540  }
541  }
542 
543  @Override
544  public List<CorrelationAttributeInstance> getArtifactInstancesByTypeValues(CorrelationAttributeInstance.Type aType, List<String> values) throws EamDbException, CorrelationAttributeNormalizationException {
545  try {
546  acquireSharedLock();
547  return super.getArtifactInstancesByTypeValues(aType, values);
548  } finally {
549  releaseSharedLock();
550  }
551  }
552 
553  @Override
554  public List<CorrelationAttributeInstance> getArtifactInstancesByTypeValuesAndCases(CorrelationAttributeInstance.Type aType, List<String> values, List<Integer> caseIds) throws EamDbException, CorrelationAttributeNormalizationException {
555  try {
556  acquireSharedLock();
557  return super.getArtifactInstancesByTypeValuesAndCases(aType, values, caseIds);
558  } finally {
559  releaseSharedLock();
560  }
561  }
562 
575  @Override
576  public Long getCountArtifactInstancesByTypeValue(CorrelationAttributeInstance.Type aType, String value) throws EamDbException, CorrelationAttributeNormalizationException {
577  try {
578  acquireSharedLock();
579  return super.getCountArtifactInstancesByTypeValue(aType, value);
580  } finally {
581  releaseSharedLock();
582  }
583  }
584 
585  @Override
586  public int getFrequencyPercentage(CorrelationAttributeInstance corAttr) throws EamDbException, CorrelationAttributeNormalizationException {
587  try {
588  acquireSharedLock();
589  return super.getFrequencyPercentage(corAttr);
590  } finally {
591  releaseSharedLock();
592  }
593  }
594 
607  @Override
608  public Long getCountUniqueCaseDataSourceTuplesHavingTypeValue(CorrelationAttributeInstance.Type aType, String value) throws EamDbException, CorrelationAttributeNormalizationException {
609  try {
610  acquireSharedLock();
611  return super.getCountUniqueCaseDataSourceTuplesHavingTypeValue(aType, value);
612  } finally {
613  releaseSharedLock();
614  }
615  }
616 
617  @Override
618  public Long getCountUniqueDataSources() throws EamDbException {
619  try {
620  acquireSharedLock();
621  return super.getCountUniqueDataSources();
622  } finally {
623  releaseSharedLock();
624  }
625  }
626 
638  @Override
639  public Long getCountArtifactInstancesByCaseDataSource(CorrelationDataSource correlationDataSource) throws EamDbException {
640  try {
641  acquireSharedLock();
642  return super.getCountArtifactInstancesByCaseDataSource(correlationDataSource);
643  } finally {
644  releaseSharedLock();
645  }
646  }
647 
652  @Override
653  public void commitAttributeInstancesBulk() throws EamDbException {
654  try {
655  acquireExclusiveLock();
656  super.commitAttributeInstancesBulk();
657  } finally {
658  releaseExclusiveLock();
659  }
660  }
661 
665  @Override
666  public void bulkInsertCases(List<CorrelationCase> cases) throws EamDbException {
667  try {
668  acquireExclusiveLock();
669  super.bulkInsertCases(cases);
670  } finally {
671  releaseExclusiveLock();
672  }
673  }
674 
685  @Override
686  public void setAttributeInstanceKnownStatus(CorrelationAttributeInstance eamArtifact, TskData.FileKnown knownStatus) throws EamDbException {
687  try {
688  acquireExclusiveLock();
689  super.setAttributeInstanceKnownStatus(eamArtifact, knownStatus);
690  } finally {
691  releaseExclusiveLock();
692  }
693  }
694 
703  @Override
704  public Long getCountArtifactInstancesKnownBad(CorrelationAttributeInstance.Type aType, String value) throws EamDbException, CorrelationAttributeNormalizationException {
705  try {
706  acquireSharedLock();
707  return super.getCountArtifactInstancesKnownBad(aType, value);
708  } finally {
709  releaseSharedLock();
710  }
711  }
712 
725  @Override
726  public List<String> getListCasesHavingArtifactInstancesKnownBad(CorrelationAttributeInstance.Type aType, String value) throws EamDbException, CorrelationAttributeNormalizationException {
727  try {
728  acquireSharedLock();
729  return super.getListCasesHavingArtifactInstancesKnownBad(aType, value);
730  } finally {
731  releaseSharedLock();
732  }
733  }
734 
742  @Override
743  public void deleteReferenceSet(int referenceSetID) throws EamDbException {
744  try {
745  acquireExclusiveLock();
746  super.deleteReferenceSet(referenceSetID);
747  } finally {
748  releaseExclusiveLock();
749  }
750  }
751 
761  @Override
762  public boolean isValueInReferenceSet(String value, int referenceSetID, int correlationTypeID) throws EamDbException, CorrelationAttributeNormalizationException {
763  try {
764  acquireSharedLock();
765  return super.isValueInReferenceSet(value, referenceSetID, correlationTypeID);
766  } finally {
767  releaseSharedLock();
768  }
769  }
770 
779  @Override
780  public void processInstanceTable(CorrelationAttributeInstance.Type type, InstanceTableCallback instanceTableCallback) throws EamDbException {
781  try {
782  acquireSharedLock();
783  super.processInstanceTable(type, instanceTableCallback);
784  } finally {
785  releaseSharedLock();
786  }
787  }
788 
797  @Override
798  public void processInstanceTableWhere(CorrelationAttributeInstance.Type type, String whereClause, InstanceTableCallback instanceTableCallback) throws EamDbException {
799  try {
800  acquireSharedLock();
801  super.processInstanceTableWhere(type, whereClause, instanceTableCallback);
802  } finally {
803  releaseSharedLock();
804  }
805  }
806 
819  @Override
820  public boolean referenceSetExists(String referenceSetName, String version) throws EamDbException {
821  try {
822  acquireSharedLock();
823  return super.referenceSetExists(referenceSetName, version);
824  } finally {
825  releaseSharedLock();
826  }
827  }
828 
837  @Override
838  public boolean isArtifactKnownBadByReference(CorrelationAttributeInstance.Type aType, String value) throws EamDbException, CorrelationAttributeNormalizationException {
839  try {
840  acquireSharedLock();
841  return super.isArtifactKnownBadByReference(aType, value);
842  } finally {
843  releaseSharedLock();
844  }
845  }
846 
856  @Override
857  public EamOrganization newOrganization(EamOrganization eamOrg) throws EamDbException {
858  try {
859  acquireExclusiveLock();
860  return super.newOrganization(eamOrg);
861  } finally {
862  releaseExclusiveLock();
863  }
864  }
865 
873  @Override
874  public List<EamOrganization> getOrganizations() throws EamDbException {
875  try {
876  acquireSharedLock();
877  return super.getOrganizations();
878  } finally {
879  releaseSharedLock();
880  }
881  }
882 
892  @Override
893  public EamOrganization getOrganizationByID(int orgID) throws EamDbException {
894  try {
895  acquireSharedLock();
896  return super.getOrganizationByID(orgID);
897  } finally {
898  releaseSharedLock();
899  }
900  }
901 
902  @Override
903  public void updateOrganization(EamOrganization updatedOrganization) throws EamDbException {
904  try {
905  acquireExclusiveLock();
906  super.updateOrganization(updatedOrganization);
907  } finally {
908  releaseExclusiveLock();
909  }
910  }
911 
912  @Override
913  public void deleteOrganization(EamOrganization organizationToDelete) throws EamDbException {
914  try {
915  acquireExclusiveLock();
916  super.deleteOrganization(organizationToDelete);
917  } finally {
918  releaseExclusiveLock();
919  }
920  }
921 
931  @Override
932  public int newReferenceSet(EamGlobalSet eamGlobalSet) throws EamDbException {
933  try {
934  acquireExclusiveLock();
935  return super.newReferenceSet(eamGlobalSet);
936  } finally {
937  releaseExclusiveLock();
938  }
939  }
940 
950  @Override
951  public EamGlobalSet getReferenceSetByID(int referenceSetID) throws EamDbException {
952  try {
953  acquireSharedLock();
954  return super.getReferenceSetByID(referenceSetID);
955  } finally {
956  releaseSharedLock();
957  }
958  }
959 
969  @Override
970  public List<EamGlobalSet> getAllReferenceSets(CorrelationAttributeInstance.Type correlationType) throws EamDbException {
971  try {
972  acquireSharedLock();
973  return super.getAllReferenceSets(correlationType);
974  } finally {
975  releaseSharedLock();
976  }
977  }
978 
988  @Override
989  public void addReferenceInstance(EamGlobalFileInstance eamGlobalFileInstance, CorrelationAttributeInstance.Type correlationType) throws EamDbException {
990  try {
991  acquireExclusiveLock();
992  super.addReferenceInstance(eamGlobalFileInstance, correlationType);
993  } finally {
994  releaseExclusiveLock();
995  }
996  }
997 
1003  @Override
1004  public void bulkInsertReferenceTypeEntries(Set<EamGlobalFileInstance> globalInstances, CorrelationAttributeInstance.Type contentType) throws EamDbException {
1005  try {
1006  acquireExclusiveLock();
1007  super.bulkInsertReferenceTypeEntries(globalInstances, contentType);
1008  } finally {
1009  releaseExclusiveLock();
1010  }
1011  }
1012 
1023  @Override
1024  public List<EamGlobalFileInstance> getReferenceInstancesByTypeValue(CorrelationAttributeInstance.Type aType, String aValue) throws EamDbException, CorrelationAttributeNormalizationException {
1025  try {
1026  acquireSharedLock();
1027  return super.getReferenceInstancesByTypeValue(aType, aValue);
1028  } finally {
1029  releaseSharedLock();
1030  }
1031  }
1032 
1042  @Override
1043  public int newCorrelationType(CorrelationAttributeInstance.Type newType) throws EamDbException {
1044  try {
1045  acquireExclusiveLock();
1046  return super.newCorrelationType(newType);
1047  } finally {
1048  releaseExclusiveLock();
1049  }
1050  }
1051 
1061  @Override
1062  public List<CorrelationAttributeInstance.Type> getDefinedCorrelationTypes() throws EamDbException {
1063  try {
1064  acquireSharedLock();
1065  return super.getDefinedCorrelationTypes();
1066  } finally {
1067  releaseSharedLock();
1068  }
1069  }
1070 
1080  @Override
1081  public List<CorrelationAttributeInstance.Type> getEnabledCorrelationTypes() throws EamDbException {
1082  try {
1083  acquireSharedLock();
1084  return super.getEnabledCorrelationTypes();
1085  } finally {
1086  releaseSharedLock();
1087  }
1088  }
1089 
1099  @Override
1100  public List<CorrelationAttributeInstance.Type> getSupportedCorrelationTypes() throws EamDbException {
1101  try {
1102  acquireSharedLock();
1103  return super.getSupportedCorrelationTypes();
1104  } finally {
1105  releaseSharedLock();
1106  }
1107  }
1108 
1116  @Override
1117  public void updateCorrelationType(CorrelationAttributeInstance.Type aType) throws EamDbException {
1118  try {
1119  acquireExclusiveLock();
1120  super.updateCorrelationType(aType);
1121  } finally {
1122  releaseExclusiveLock();
1123  }
1124  }
1125 
1135  @Override
1136  public CorrelationAttributeInstance.Type getCorrelationTypeById(int typeId) throws EamDbException {
1137  try {
1138  acquireSharedLock();
1139  return super.getCorrelationTypeById(typeId);
1140  } finally {
1141  releaseSharedLock();
1142  }
1143  }
1144 
1150  @Override
1151  public void upgradeSchema() throws EamDbException, SQLException, IncompatibleCentralRepoException {
1152  try {
1153  acquireExclusiveLock();
1154  super.upgradeSchema();
1155  } finally {
1156  releaseExclusiveLock();
1157  }
1158  }
1159 
1171  @Override
1172  public CoordinationService.Lock getExclusiveMultiUserDbLock() throws EamDbException {
1173  // Multiple users are not supported for SQLite
1174  return null;
1175  }
1176 
1182  private void acquireExclusiveLock() {
1183  rwLock.writeLock().lock();
1184  }
1185 
1191  private void releaseExclusiveLock() {
1192  rwLock.writeLock().unlock();
1193  }
1194 
1200  private void acquireSharedLock() {
1201  rwLock.readLock().lock();
1202  }
1203 
1209  private void releaseSharedLock() {
1210  rwLock.readLock().unlock();
1211  }
1212 
1213  @Override
1214  boolean doesColumnExist(Connection conn, String tableName, String columnName) throws SQLException {
1215  final String tableInfoQueryTemplate = "PRAGMA table_info(%s)"; //NON-NLS
1216  ResultSet resultSet = null;
1217  Statement statement = null;
1218  boolean columnExists = false;
1219  try {
1220  statement = conn.createStatement();
1221  resultSet = statement.executeQuery(String.format(tableInfoQueryTemplate, tableName));
1222  while (resultSet.next()) {
1223  // the second value ( 2 ) is the column name
1224  if (resultSet.getString(2).equals(columnName)) {
1225  columnExists = true;
1226  break;
1227  }
1228  }
1229  } finally {
1230  EamDbUtil.closeResultSet(resultSet);
1231  EamDbUtil.closeStatement(statement);
1232  }
1233  return columnExists;
1234  }
1235 }

Copyright © 2012-2018 Basis Technology. Generated on: Fri Jun 21 2019
This work is licensed under a Creative Commons Attribution-Share Alike 3.0 United States License.