CaseDbAccessManager.java

Go to the documentation of this file.

/*
 * Sleuth Kit Data Model
 *
 * Copyright 2018-2019 Basis Technology Corp.
 * Contact: carrier <at> sleuthkit <dot> org
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.sleuthkit.datamodel;
 
import com.google.common.annotations.Beta;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Time;
import java.sql.Timestamp;
import java.text.MessageFormat;
import java.sql.Date;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.sleuthkit.datamodel.SleuthkitCase.CaseDbConnection;
import org.sleuthkit.datamodel.SleuthkitCase.CaseDbTransaction;
import static org.sleuthkit.datamodel.SleuthkitCase.closeStatement;
import org.sleuthkit.datamodel.TskData.DbType;

public final class CaseDbAccessManager {
        
        public interface CaseDbAccessQueryCallback {

           void process(ResultSet resultSet);
 
   }
 
 
        private static final Logger logger = Logger.getLogger(CaseDbAccessManager.class.getName());
 
        private final SleuthkitCase tskDB;

        CaseDbAccessManager(SleuthkitCase skCase) {
                this.tskDB = skCase;
        }

        public boolean columnExists(String tableName, String columnName) throws TskCoreException {
                
                boolean doesColumnExists = false;
                CaseDbTransaction localTrans = tskDB.beginTransaction();
        try {
                        doesColumnExists = columnExists(tableName, columnName, localTrans);
                        localTrans.commit();
                        localTrans = null;
        } 
                finally {
                        if (null != localTrans) {
                                try {
                                        localTrans.rollback();
                                } catch (TskCoreException ex) {
                                        logger.log(Level.SEVERE, "Failed to rollback transaction after exception", ex);
                                }
                        }
                }
                
        return doesColumnExists;
    }
        
        public boolean columnExists(String tableName, String columnName, CaseDbTransaction transaction) throws TskCoreException {
                
                boolean columnExists = false;
        Statement statement = null;
                ResultSet resultSet = null;
        try {
                        CaseDbConnection connection = transaction.getConnection();
                        statement = connection.createStatement();
                        if (DbType.SQLITE == tskDB.getDatabaseType()) {
                                String tableInfoQuery = "PRAGMA table_info(%s)";  //NON-NLS
                                resultSet = statement.executeQuery(String.format(tableInfoQuery, tableName));
                                while (resultSet.next()) {
                                        if (resultSet.getString("name").equalsIgnoreCase(columnName)) {
                                                columnExists = true;
                                                break;
                                        }
                                }
                        }
                        else {
                                String tableInfoQueryTemplate = "SELECT EXISTS (SELECT 1 FROM information_schema.columns WHERE table_name='%s' AND column_name='%s')";  //NON-NLS       
                                resultSet = statement.executeQuery(String.format(tableInfoQueryTemplate, tableName.toLowerCase(), columnName.toLowerCase()));
                                if (resultSet.next()) {
                                        columnExists = resultSet.getBoolean(1);
                                }
                        }
        } 
                catch (SQLException ex) {
                        throw new TskCoreException("Error checking if column  " + columnName + "exists ", ex);
                } 
                finally {
                        if (resultSet != null) {
                                try {
                                        resultSet.close();
                                } catch (SQLException ex2) {
                                        logger.log(Level.WARNING, "Failed to to close resultset after checking column", ex2);
                                }
                        }
            closeStatement(statement);
        }
        return columnExists;
    }
        
        public boolean tableExists(String tableName) throws TskCoreException {
                
                boolean doesTableExist = false;
                CaseDbTransaction localTrans = tskDB.beginTransaction();
        try {
                        doesTableExist = tableExists(tableName, localTrans);
                        localTrans.commit();
                        localTrans = null;
        } 
                finally {
                        if (null != localTrans) {
                                try {
                                        localTrans.rollback();
                                } catch (TskCoreException ex) {
                                        logger.log(Level.SEVERE, "Failed to rollback transaction after exception", ex); //NON-NLS
                                }
                        }
                }
                
        return doesTableExist;
    }
        
        public boolean tableExists(String tableName, CaseDbTransaction transaction) throws TskCoreException {
                
                boolean tableExists = false;
        Statement statement = null;
                ResultSet resultSet = null;
        try {
                        CaseDbConnection connection = transaction.getConnection();
                        statement = connection.createStatement();
                        if (DbType.SQLITE == tskDB.getDatabaseType()) {
                                resultSet = statement.executeQuery("SELECT name FROM sqlite_master WHERE type='table'");  //NON-NLS
                                while (resultSet.next()) {
                                        if (resultSet.getString("name").equalsIgnoreCase(tableName)) { //NON-NLS
                                                tableExists = true;
                                                break;
                                        }
                                }
                        }
                        else {
                                String tableInfoQueryTemplate = "SELECT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name='%s')";  //NON-NLS     
                                resultSet = statement.executeQuery(String.format(tableInfoQueryTemplate, tableName.toLowerCase()));
                                if (resultSet.next()) {
                                        tableExists = resultSet.getBoolean(1);
                                }
                        }
        } 
                catch (SQLException ex) {
                        throw new TskCoreException("Error checking if table  " + tableName + "exists ", ex);
                } finally {
                        if (resultSet != null) {
                                try {
                                        resultSet.close();
                                } catch (SQLException ex2) {
                                        logger.log(Level.WARNING, "Failed to to close resultset after checking table", ex2);
                                }
                        }
            closeStatement(statement);
        }
        return tableExists;
    }
        
        public void createTable(final String tableName, final String tableSchema) throws TskCoreException {
 
                validateTableName(tableName);
                validateSQL(tableSchema);
 
                tskDB.acquireSingleUserCaseWriteLock();
                String createSQL = "CREATE TABLE IF NOT EXISTS " + tableName + " " + tableSchema;
                try (CaseDbConnection connection = tskDB.getConnection();
                                Statement statement = connection.createStatement();) {
                        statement.execute(createSQL);
                } catch (SQLException ex) {
                        throw new TskCoreException("Error creating table " + tableName, ex);
                } finally {
                        tskDB.releaseSingleUserCaseWriteLock();
                }
        }

        public void alterTable(final String tableName, final String alterSQL) throws TskCoreException {
                
                CaseDbTransaction localTrans = tskDB.beginTransaction();
                try {
                        alterTable(tableName, alterSQL, localTrans);
                        localTrans.commit();
                        localTrans = null;
                } finally {
                        if (null != localTrans) {
                                try {
                                        localTrans.rollback();
                                } catch (TskCoreException ex) {
                                        logger.log(Level.SEVERE, "Failed to rollback transaction after exception", ex);
                                }
                        }
                } 
        }
                
        public void alterTable(final String tableName, final String alterSQL, final CaseDbTransaction transaction) throws TskCoreException {
 
                validateTableName(tableName);
                validateSQL(alterSQL);
 
                CaseDbConnection connection = transaction.getConnection();
 
                Statement statement = null;
                String sql = "ALTER TABLE " + tableName + " " + alterSQL;
                
                try {
                        statement = connection.createStatement();
                        statement.execute(sql);
                } catch (SQLException ex) {
                        // SQLite occasionally returns false for columnExists() if a table was just created with that column
                        // leading to "duplicate column name" exception.
                        // We ignore this exception
                        if (DbType.SQLITE == tskDB.getDatabaseType() &&
                                        alterSQL.toLowerCase().contains("add column") &&
                                        ex.getMessage().toLowerCase().contains("duplicate column name")) {
                                logger.log(Level.WARNING, String.format("Column being added by SQL = %s already exists in table %s", alterSQL, tableName));
                                return;
                        }
                        throw new TskCoreException(String.format("Error altering table  %s with SQL = %s", tableName, sql), ex);
                } finally {
                        closeStatement(statement);
                }
        }
        
        public void createIndex(final String indexName, final String tableName, final String colsSQL) throws TskCoreException {
 
                validateTableName(tableName);
                validateIndexName(indexName);
                validateSQL(colsSQL);
 
                tskDB.acquireSingleUserCaseWriteLock();
                String indexSQL = "CREATE INDEX IF NOT EXISTS " + indexName + " ON " + tableName + " " + colsSQL; // NON-NLS
                try (CaseDbConnection connection = tskDB.getConnection();
                        Statement statement = connection.createStatement(); ) {
                        statement.execute(indexSQL);
                } catch (SQLException ex) {
                        throw new TskCoreException("Error creating index " + tableName, ex);
                } finally {
                        tskDB.releaseSingleUserCaseWriteLock();
                }
        }

        public long insert(final String tableName, final String sql) throws TskCoreException {
                
                CaseDbTransaction localTrans = tskDB.beginTransaction();
                try {
                        long rowId = insert(tableName, sql, localTrans);
                        localTrans.commit();
                        localTrans = null;
                        return rowId;
                } finally {
                        if (null != localTrans) {
                                try {
                                        localTrans.rollback();
                                } catch (TskCoreException ex) {
                                        logger.log(Level.SEVERE, "Failed to rollback transaction after exception", ex);
                                }
                        }
                } 
                
        }
        
        public long insert(final String tableName, final String sql, final CaseDbTransaction transaction) throws TskCoreException {
                long rowId = 0;
 
                validateTableName(tableName);
                validateSQL(sql);
 
                CaseDbConnection connection = transaction.getConnection();
 
                PreparedStatement statement = null;
                ResultSet resultSet;
                String insertSQL = "INSERT";
                if (DbType.SQLITE == tskDB.getDatabaseType()) {
                        insertSQL += " OR IGNORE";
                }
                
                insertSQL = insertSQL+ " INTO " + tableName + " " + sql; // NON-NLS
                try {
                        statement = connection.prepareStatement(insertSQL, Statement.RETURN_GENERATED_KEYS);
                        connection.executeUpdate(statement);
                        
                        resultSet = statement.getGeneratedKeys();
                        if (resultSet.next()) {
                                rowId = resultSet.getLong(1); //last_insert_rowid()
                        }
                } catch (SQLException ex) {
                        throw new TskCoreException("Error inserting row in table " + tableName + " with sql = "+ insertSQL, ex);
                } finally {
                        closeStatement(statement);
                }
 
                return rowId;
        }
        
        public long insertOrUpdate(final String tableName, final String sql) throws TskCoreException {
                
                CaseDbTransaction localTrans = tskDB.beginTransaction();
                try {
                        long rowId = insertOrUpdate(tableName, sql, localTrans);
                        localTrans.commit();
                        localTrans = null;
                        return rowId;
                } finally {
                        if (null != localTrans) {
                                try {
                                        localTrans.rollback();
                                } catch (TskCoreException ex) {
                                        logger.log(Level.SEVERE, "Failed to rollback transaction after exception", ex);
                                }
                        }
                } 
                
        }
        
        public long insertOrUpdate(final String tableName, final String sql, final CaseDbTransaction transaction) throws TskCoreException {
                long rowId = 0;
 
                validateTableName(tableName);
                validateSQL(sql);
 
                CaseDbConnection connection = transaction.getConnection();
 
                PreparedStatement statement = null;
                ResultSet resultSet;
                String insertSQL = "INSERT";
                if (DbType.SQLITE == tskDB.getDatabaseType()) {
                        insertSQL += " OR REPLACE";
                }
                
                insertSQL += " INTO " + tableName + " " + sql; // NON-NLS
                try {
                        statement = connection.prepareStatement(insertSQL, Statement.RETURN_GENERATED_KEYS);
                        connection.executeUpdate(statement);
 
                        resultSet = statement.getGeneratedKeys();
                        resultSet.next();
                        rowId = resultSet.getLong(1); //last_insert_rowid()
                } catch (SQLException ex) {
                        throw new TskCoreException("Error inserting row in table " + tableName + " with sql = "+ insertSQL, ex);
                } finally {
                        closeStatement(statement);
                }
 
                return rowId;
        }
        
        @Beta
        public CaseDbPreparedStatement prepareUpdate(String tableName, String sql, CaseDbTransaction trans) throws TskCoreException {
                validateTableName(tableName);
                validateSQL(sql);
 
                String updateSQL = "UPDATE " + tableName + " " + sql; // NON-NLS
        
                try {
                        return new CaseDbPreparedStatement(StatementType.UPDATE, updateSQL, trans);
                } catch (SQLException ex) {
                        throw new TskCoreException("Error creating update prepared statement for query:\n" + updateSQL, ex);
                }
        }
        
        @Beta
        public void update(CaseDbPreparedStatement preparedStatement) throws TskCoreException {
                
                if (!preparedStatement.getType().equals(StatementType.UPDATE)) {
                        throw new TskCoreException("CaseDbPreparedStatement has incorrect type for update operation");
                }
                
                try {
                        preparedStatement.getStatement().executeUpdate();
                } catch (SQLException ex) {
                        throw new TskCoreException("Error updating row in table " + "" + " with sql = "+ "", ex);
                }
        }       
        
        public void update(final String tableName, final String sql) throws TskCoreException {
                CaseDbTransaction localTrans = tskDB.beginTransaction();
                try {
                        update(tableName, sql, localTrans);
                        localTrans.commit();
                        localTrans = null;
                } finally {
                        if (null != localTrans) {
                                try {
                                        localTrans.rollback();
                                } catch (TskCoreException ex) {
                                        logger.log(Level.SEVERE, "Failed to rollback transaction after exception", ex);
                                }
                        }
                } 
        }
        

        public void update(final String tableName, final String sql, CaseDbTransaction transaction ) throws TskCoreException {
                
                validateTableName(tableName);
                validateSQL(sql);
 
                CaseDbConnection connection = transaction.getConnection();
 
                Statement statement = null;
                String updateSQL = "UPDATE " + tableName + " " + sql; // NON-NLS
 
                try {
                        statement = connection.createStatement();
                        statement.executeUpdate(updateSQL);
                } catch (SQLException ex) {
                        throw new TskCoreException("Error Updating table " + tableName, ex);
                } finally {
                        closeStatement(statement);
                }
        }
        
        public void select(final String sql, final CaseDbAccessQueryCallback queryCallback) throws TskCoreException {
 
                if (queryCallback == null) {
            throw new TskCoreException("Callback is null");
        }
                
                validateSQL(sql);
                
                tskDB.acquireSingleUserCaseReadLock();
                String selectSQL = "SELECT " +  sql; // NON-NLS
                try (CaseDbConnection connection = tskDB.getConnection();
                        Statement statement = connection.createStatement();
                        ResultSet resultSet = statement.executeQuery(selectSQL)) {
                        queryCallback.process(resultSet);
                } catch (SQLException ex) {
                        throw new TskCoreException("Error running SELECT query.", ex);
                } finally {
                        tskDB.releaseSingleUserCaseReadLock();
                }
        }
        
        @Beta
        public CaseDbPreparedStatement prepareSelect(String sql) throws TskCoreException {
                String selectSQL = "SELECT " + sql; // NON-NLS
                try {
                        return new CaseDbPreparedStatement(StatementType.SELECT, selectSQL, false);
                } catch (SQLException ex) {
                        throw new TskCoreException("Error creating select prepared statement for query:\n" + selectSQL, ex);
                }
        }
        
        @Beta
        public CaseDbPreparedStatement prepareSelect(String sql, CaseDbTransaction trans) throws TskCoreException {
                validateSQL(sql);
 
                String selectSQL = "SELECT " + sql; // NON-NLS
 
                try {
                        return new CaseDbPreparedStatement(StatementType.SELECT, selectSQL, trans);
                } catch (SQLException ex) {
                        throw new TskCoreException("Error creating select prepared statement for query:\n" + selectSQL, ex);
                }
        }
 

        @Beta
        public void select(CaseDbPreparedStatement preparedStatement, CaseDbAccessQueryCallback queryCallback) throws TskCoreException {
                if (!preparedStatement.getType().equals(StatementType.SELECT)) {
                        throw new TskCoreException("CaseDbPreparedStatement has incorrect type for select operation");
                }
                
                try (ResultSet resultSet = preparedStatement.getStatement().executeQuery()) {
                        queryCallback.process(resultSet);
                } catch (SQLException ex) {
                        throw new TskCoreException(MessageFormat.format("Error running SELECT query:\n{0}", preparedStatement.getOriginalSql()), ex);
                }
        }
        
        @Beta
        public void select(CaseDbPreparedStatement preparedStatement, boolean runOptimize, CaseDbAccessQueryCallback queryCallback) throws TskCoreException {
                if (runOptimize && this.tskDB.getDatabaseType() == DbType.SQLITE) {
                        try (Statement optimizeStmt = preparedStatement.connection.createStatement()) {
                                optimizeStmt.execute("PRAGMA optimize");
                        } catch (SQLException ex) {
                                throw new TskCoreException("An error occurred while attempting to optimize the call", ex);
                        }
                }
                
                select(preparedStatement, queryCallback);
        }
        
        @Beta
        public void runAnalyze() throws TskCoreException {
                CaseDbTransaction localTrans = tskDB.beginTransaction();
 
                try {
                        CaseDbConnection connection = localTrans.getConnection();
 
                        try (Statement statement = connection.createStatement()) {
                                statement.executeUpdate("ANALYZE");
                        } catch (SQLException ex) {
                                throw new TskCoreException("An error occurred while attempting to run ANALYZE", ex);
                        }
                        localTrans.commit();
                        localTrans = null;
                } finally {
                        if (null != localTrans) {
                                try {
                                        localTrans.rollback();
                                } catch (TskCoreException ex) {
                                        logger.log(Level.SEVERE, "Failed to rollback transaction after exception", ex);
                                }
                        }
                }
        }
        
        @Beta
        public CaseDbPreparedStatement prepareInsert(String tableName, String sql, CaseDbTransaction trans) throws TskCoreException {
                validateTableName(tableName);
                validateSQL(sql);
                
                String insertSQL = "INSERT";
                if (DbType.SQLITE == tskDB.getDatabaseType()) {
                        insertSQL += " OR IGNORE";
                }
                insertSQL = insertSQL + " INTO " + tableName + " " + sql; // NON-NLS
        
                try {
                        return new CaseDbPreparedStatement(StatementType.INSERT, insertSQL, trans);
                } catch (SQLException ex) {
                        throw new TskCoreException("Error creating insert prepared statement for query:\n" + insertSQL, ex);
                }
        }
        
        @Beta
        public void insert(CaseDbPreparedStatement preparedStatement) throws TskCoreException {
                
                if (!preparedStatement.getType().equals(StatementType.INSERT)) {
                        throw new TskCoreException("CaseDbPreparedStatement has incorrect type for insert operation");
                }
                
                try {
                        preparedStatement.getStatement().executeUpdate();
                } catch (SQLException ex) {
                        throw new TskCoreException("Error inserting row in table " + "" + " with sql = "+ "", ex);
                }
        }

        public void delete(final String tableName, final String sql ) throws TskCoreException {
                validateTableName(tableName);
                validateSQL(sql);
 
                tskDB.acquireSingleUserCaseWriteLock();
                String deleteSQL = "DELETE FROM " + tableName + " " + sql; // NON-NLS
                try (CaseDbConnection connection = tskDB.getConnection();
                        Statement statement = connection.createStatement();) {
                        statement.executeUpdate(deleteSQL);
                } catch (SQLException ex) {
                        throw new TskCoreException("Error deleting row from table " + tableName, ex);
                } finally {
                        tskDB.releaseSingleUserCaseWriteLock();
                }
        }

        private void validateTableName(String tableName) throws TskCoreException {
                
                if (SleuthkitCase.getCoreTableNames().contains(tableName.toLowerCase())) {
                        throw new TskCoreException("Attempt to modify a core TSK table " + tableName);
                }
                if (tableName.toLowerCase().startsWith("tsk_")) {
                        throw new TskCoreException("Modifying tables with tsk_ prefix is not allowed. ");
                }
        }

        private void validateIndexName(String indexName) throws TskCoreException {
                
                if (indexName.isEmpty()) {
                        throw new TskCoreException("Invalid index name " + indexName);  
                }
                
                if (SleuthkitCase.getCoreIndexNames().contains(indexName.toLowerCase())) {
                        throw new TskCoreException("Attempt to modify a core TSK index " + indexName);  
                }
        }
        
        private void validateSQL(String sql) throws TskCoreException {
                /*
                 * TODO (JIRA-5950): Need SQL injection defense in CaseDbAccessManager 
                 */
        }
        
        private enum LockType {
                READ,
                WRITE,
                NONE;
        }
        
        private enum StatementType {
                SELECT,
                INSERT,
                UPDATE;
        }
        
        @Beta
        public class CaseDbPreparedStatement implements AutoCloseable {
 
                private final CaseDbConnection connection;
                private final PreparedStatement preparedStatement;
                private final String originalSql;
                private final LockType lockType;
                private final StatementType type;
                
                private CaseDbPreparedStatement(StatementType type, String query, boolean isWriteLockRequired) throws SQLException, TskCoreException {          
                        if (isWriteLockRequired) {
                                CaseDbAccessManager.this.tskDB.acquireSingleUserCaseWriteLock();
                                this.lockType = LockType.WRITE;
                        } else {
                                CaseDbAccessManager.this.tskDB.acquireSingleUserCaseReadLock();
                                this.lockType = LockType.READ;
                        }
                        this.connection = tskDB.getConnection();
                        this.preparedStatement = connection.getPreparedStatement(query, Statement.NO_GENERATED_KEYS);
                        this.originalSql = query;
                        this.type = type;
                }
                
                private CaseDbPreparedStatement(StatementType type, String query, CaseDbTransaction trans) throws SQLException, TskCoreException {              
                        this.lockType = LockType.NONE;
                        this.connection = trans.getConnection();
                        this.preparedStatement = connection.getPreparedStatement(query, Statement.NO_GENERATED_KEYS);
                        this.originalSql = query;
                        this.type = type;
                }

                private PreparedStatement getStatement() {
                        return preparedStatement;
                }
                
                private StatementType getType() {
                        return type;
                }

                private String getOriginalSql() {
                        return originalSql;
                }
                
                public void reset() throws TskCoreException {
                        try {
                                preparedStatement.clearParameters();
                        } catch (SQLException ex) {
                                throw new TskCoreException("An error occurred while clearing parameters.", ex);
                        }
                }

                public void setBoolean(int parameterIndex, boolean x) throws TskCoreException {
                        try {
                                preparedStatement.setBoolean(parameterIndex, x);
                        } catch (SQLException ex) {
                                throw new TskCoreException(MessageFormat.format("There was an error setting the value at index: {0} to {1}", parameterIndex, x), ex);
                        }
                }

                public void setByte(int parameterIndex, byte x) throws TskCoreException {
                        try {
                                preparedStatement.setByte(parameterIndex, x);
                        } catch (SQLException ex) {
                                throw new TskCoreException(MessageFormat.format("There was an error setting the value at index: {0} to {1}", parameterIndex, x), ex);
                        }
                }

                public void setInt(int parameterIndex, int x) throws TskCoreException {
                        try {
                                preparedStatement.setInt(parameterIndex, x);
                        } catch (SQLException ex) {
                                throw new TskCoreException(MessageFormat.format("There was an error setting the value at index: {0} to {1}", parameterIndex, x), ex);
                        }
                }

                public void setLong(int parameterIndex, long x) throws TskCoreException {
                        try {
                                preparedStatement.setLong(parameterIndex, x);
                        } catch (SQLException ex) {
                                throw new TskCoreException(MessageFormat.format("There was an error setting the value at index: {0} to {1}", parameterIndex, x), ex);
                        }
                }

                public void setDouble(int parameterIndex, double x) throws TskCoreException {
                        try {
                                preparedStatement.setDouble(parameterIndex, x);
                        } catch (SQLException ex) {
                                throw new TskCoreException(MessageFormat.format("There was an error setting the value at index: {0} to {1}", parameterIndex, x), ex);
                        }
                }

                public void setString(int parameterIndex, String x) throws TskCoreException {
                        try {
                                preparedStatement.setString(parameterIndex, x);
                        } catch (SQLException ex) {
                                throw new TskCoreException(MessageFormat.format("There was an error setting the value at index: {0} to {1}", parameterIndex, x), ex);
                        }
                }

                public void setDate(int parameterIndex, Date x) throws TskCoreException {
                        try {
                                preparedStatement.setDate(parameterIndex, x);
                        } catch (SQLException ex) {
                                throw new TskCoreException(MessageFormat.format("There was an error setting the value at index: {0} to {1}", parameterIndex, x), ex);
                        }
                }

                public void setTime(int parameterIndex, Time x) throws TskCoreException {
                        try {
                                preparedStatement.setTime(parameterIndex, x);
                        } catch (SQLException ex) {
                                throw new TskCoreException(MessageFormat.format("There was an error setting the value at index: {0} to {1}", parameterIndex, x), ex);
                        }
                }

                public void setTimestamp(int parameterIndex, Timestamp x) throws TskCoreException {
                        try {
                                preparedStatement.setTimestamp(parameterIndex, x);
                        } catch (SQLException ex) {
                                throw new TskCoreException(MessageFormat.format("There was an error setting the value at index: {0} to {1}", parameterIndex, x), ex);
                        }
                }

                public void setObject(int parameterIndex, Object x) throws TskCoreException {
                        try {
                                preparedStatement.setObject(parameterIndex, x);
                        } catch (SQLException ex) {
                                throw new TskCoreException(MessageFormat.format("There was an error setting the value at index: {0} to {1}", parameterIndex, x), ex);
                        }
                }
 
                @Override
                public void close() throws SQLException {
                        
                        // Don't close the statement/connection or release a lock if we were supplied a transaction.
                        // Everything will be handled when the transaction is closed.
                        if (lockType.equals(LockType.NONE)) {
                                return;
                        }
                        
                        connection.close();
                        if (lockType.equals(LockType.WRITE)) {
                                CaseDbAccessManager.this.tskDB.releaseSingleUserCaseWriteLock();
                        } else {
                                CaseDbAccessManager.this.tskDB.releaseSingleUserCaseReadLock();
                        }
                }
        }
 
}