Exemplo n.º 1
0
/**
 * Internal iterator so we can page through the class. This is used by the {@link Dao#iterator}
 * methods.
 *
 * @param <T> The class that the code will be operating on.
 * @param <ID> The class of the ID column associated with the class. The T class does not require an
 *     ID field. The class needs an ID parameter however so you can use Void or Object to satisfy
 *     the compiler.
 * @author graywatson
 */
public class SelectIterator<T, ID> implements CloseableIterator<T> {

  private static final Logger logger = LoggerFactory.getLogger(SelectIterator.class);

  private final Class<?> dataClass;
  private final Dao<T, ID> classDao;
  private final ConnectionSource connectionSource;
  private final DatabaseConnection connection;
  private final CompiledStatement compiledStmt;
  private final DatabaseResults results;
  private final GenericRowMapper<T> rowMapper;
  private final String statement;
  private boolean first = true;
  private boolean closed;
  private boolean alreadyMoved;
  private T last;
  private int rowC;

  /** If the statement parameter is null then this won't log information */
  public SelectIterator(
      Class<?> dataClass,
      Dao<T, ID> classDao,
      GenericRowMapper<T> rowMapper,
      ConnectionSource connectionSource,
      DatabaseConnection connection,
      CompiledStatement compiledStmt,
      String statement,
      ObjectCache objectCache)
      throws SQLException {
    this.dataClass = dataClass;
    this.classDao = classDao;
    this.rowMapper = rowMapper;
    this.connectionSource = connectionSource;
    this.connection = connection;
    this.compiledStmt = compiledStmt;
    this.results = compiledStmt.runQuery(objectCache);
    this.statement = statement;
    if (statement != null) {
      logger.debug("starting iterator @{} for '{}'", hashCode(), statement);
    }
  }

  /**
   * Returns whether or not there are any remaining objects in the table. Can be called before
   * next().
   *
   * @throws SQLException If there was a problem getting more results via SQL.
   */
  public boolean hasNextThrow() throws SQLException {
    if (closed) {
      return false;
    }
    if (alreadyMoved) {
      // we do this so multiple hasNext() calls can be made, result would be true or closed is true
      return true;
    }
    boolean result;
    if (first) {
      first = false;
      result = results.first();
    } else {
      result = results.next();
    }
    if (!result) {
      close();
    }
    alreadyMoved = true;
    return result;
  }

  /**
   * Returns whether or not there are any remaining objects in the table. Can be called before
   * next().
   *
   * @throws IllegalStateException If there was a problem getting more results via SQL.
   */
  public boolean hasNext() {
    try {
      return hasNextThrow();
    } catch (SQLException e) {
      last = null;
      closeQuietly();
      // unfortunately, can't propagate back the SQLException
      throw new IllegalStateException("Errors getting more results of " + dataClass, e);
    }
  }

  public T first() throws SQLException {
    if (closed) {
      return null;
    }
    first = false;
    if (results.first()) {
      return getCurrent();
    } else {
      return null;
    }
  }

  public T previous() throws SQLException {
    if (closed) {
      return null;
    }
    first = false;
    if (results.previous()) {
      return getCurrent();
    } else {
      return null;
    }
  }

  public T current() throws SQLException {
    if (closed) {
      return null;
    }
    if (first) {
      return first();
    } else {
      return getCurrent();
    }
  }

  public T nextThrow() throws SQLException {
    if (closed) {
      return null;
    }
    if (!alreadyMoved) {
      boolean hasResult;
      if (first) {
        first = false;
        hasResult = results.first();
      } else {
        hasResult = results.next();
      }
      // move forward
      if (!hasResult) {
        first = false;
        return null;
      }
    }
    first = false;
    return getCurrent();
  }

  /**
   * Returns the next object in the table.
   *
   * @throws IllegalStateException If there was a problem extracting the object from SQL.
   */
  public T next() {
    SQLException sqlException = null;
    try {
      T result = nextThrow();
      if (result != null) {
        return result;
      }
    } catch (SQLException e) {
      sqlException = e;
    }
    // we have to throw if there is no next or on a SQLException
    last = null;
    closeQuietly();
    throw new IllegalStateException("Could not get next result for " + dataClass, sqlException);
  }

  public T moveRelative(int offset) throws SQLException {
    if (closed) {
      return null;
    }
    first = false;
    if (results.moveRelative(offset)) {
      return getCurrent();
    } else {
      return null;
    }
  }

  /**
   * Removes the last object returned by next() by calling delete on the dao associated with the
   * object.
   *
   * @throws IllegalStateException If there was no previous next() call.
   * @throws SQLException If the delete failed.
   */
  public void removeThrow() throws SQLException {
    if (last == null) {
      throw new IllegalStateException(
          "No last " + dataClass + " object to remove. Must be called after a call to next.");
    }
    if (classDao == null) {
      // we may never be able to get here since it should only be null for queryForAll methods
      throw new IllegalStateException(
          "Cannot remove " + dataClass + " object because classDao not initialized");
    }
    try {
      classDao.delete(last);
    } finally {
      // if we've try to delete it, clear the last marker
      last = null;
    }
  }

  /**
   * Removes the last object returned by next() by calling delete on the dao associated with the
   * object.
   *
   * @throws IllegalStateException If there was no previous next() call or if delete() throws a
   *     SQLException (set as the cause).
   */
  public void remove() {
    try {
      removeThrow();
    } catch (SQLException e) {
      closeQuietly();
      // unfortunately, can't propagate back the SQLException
      throw new IllegalStateException("Could not delete " + dataClass + " object " + last, e);
    }
  }

  public void close() throws SQLException {
    if (!closed) {
      compiledStmt.close();
      closed = true;
      last = null;
      if (statement != null) {
        logger.debug("closed iterator @{} after {} rows", hashCode(), rowC);
      }
      connectionSource.releaseConnection(connection);
    }
  }

  public void closeQuietly() {
    try {
      close();
    } catch (SQLException e) {
      // ignore it
    }
  }

  public DatabaseResults getRawResults() {
    return results;
  }

  public void moveToNext() {
    last = null;
    first = false;
    alreadyMoved = false;
  }

  private T getCurrent() throws SQLException {
    last = rowMapper.mapRow(results);
    alreadyMoved = false;
    rowC++;
    return last;
  }
}
/**
 * Database connection for Android.
 *
 * @author kevingalligan, graywatson
 */
public class AndroidDatabaseConnection implements DatabaseConnection {

  private static final String ANDROID_VERSION = "VERSION__4.49-SNAPSHOT__";

  private static Logger logger = LoggerFactory.getLogger(AndroidDatabaseConnection.class);
  private static final String[] NO_STRING_ARGS = new String[0];

  private final SQLiteDatabase db;
  private final boolean readWrite;
  private final boolean cancelQueriesEnabled;

  static {
    VersionUtils.checkCoreVersusAndroidVersions(ANDROID_VERSION);
  }

  public AndroidDatabaseConnection(SQLiteDatabase db, boolean readWrite) {
    this(db, readWrite, false);
  }

  public AndroidDatabaseConnection(
      SQLiteDatabase db, boolean readWrite, boolean cancelQueriesEnabled) {
    this.db = db;
    this.readWrite = readWrite;
    this.cancelQueriesEnabled = cancelQueriesEnabled;
    logger.trace("{}: db {} opened, read-write = {}", this, db, readWrite);
  }

  public boolean isAutoCommitSupported() {
    return true;
  }

  public boolean isAutoCommit() throws SQLException {
    try {
      boolean inTransaction = db.inTransaction();
      logger.trace("{}: in transaction is {}", this, inTransaction);
      // You have to explicitly commit your transactions, so this is sort of correct
      return !inTransaction;
    } catch (android.database.SQLException e) {
      throw SqlExceptionUtil.create("problems getting auto-commit from database", e);
    }
  }

  public void setAutoCommit(boolean autoCommit) {
    /*
     * Sqlite does not support auto-commit. The various JDBC drivers seem to implement it with the use of a
     * transaction. That's what we are doing here.
     */
    if (autoCommit) {
      if (db.inTransaction()) {
        db.setTransactionSuccessful();
        db.endTransaction();
      }
    } else {
      if (!db.inTransaction()) {
        db.beginTransaction();
      }
    }
  }

  public Savepoint setSavePoint(String name) throws SQLException {
    try {
      db.beginTransaction();
      logger.trace("{}: save-point set with name {}", this, name);
      return new OurSavePoint(name);
    } catch (android.database.SQLException e) {
      throw SqlExceptionUtil.create("problems beginning transaction " + name, e);
    }
  }

  /** Return whether this connection is read-write or not (real-only). */
  public boolean isReadWrite() {
    return readWrite;
  }

  public void commit(Savepoint savepoint) throws SQLException {
    try {
      db.setTransactionSuccessful();
      db.endTransaction();
      if (savepoint == null) {
        logger.trace("{}: transaction is successfuly ended", this);
      } else {
        logger.trace("{}: transaction {} is successfuly ended", this, savepoint.getSavepointName());
      }
    } catch (android.database.SQLException e) {
      if (savepoint == null) {
        throw SqlExceptionUtil.create("problems commiting transaction", e);
      } else {
        throw SqlExceptionUtil.create(
            "problems commiting transaction " + savepoint.getSavepointName(), e);
      }
    }
  }

  public void rollback(Savepoint savepoint) throws SQLException {
    try {
      // no setTransactionSuccessful() means it is a rollback
      db.endTransaction();
      if (savepoint == null) {
        logger.trace("{}: transaction is ended, unsuccessfuly", this);
      } else {
        logger.trace(
            "{}: transaction {} is ended, unsuccessfuly", this, savepoint.getSavepointName());
      }
    } catch (android.database.SQLException e) {
      if (savepoint == null) {
        throw SqlExceptionUtil.create("problems rolling back transaction", e);
      } else {
        throw SqlExceptionUtil.create(
            "problems rolling back transaction " + savepoint.getSavepointName(), e);
      }
    }
  }

  public int executeStatement(String statementStr, int resultFlags) throws SQLException {
    return AndroidCompiledStatement.execSql(db, statementStr, statementStr, NO_STRING_ARGS);
  }

  public CompiledStatement compileStatement(
      String statement, StatementType type, FieldType[] argFieldTypes, int resultFlags) {
    // resultFlags argument is not used in Android-land since the {@link Cursor} is bi-directional.
    CompiledStatement stmt =
        new AndroidCompiledStatement(statement, db, type, cancelQueriesEnabled);
    logger.trace("{}: compiled statement got {}: {}", this, stmt, statement);
    return stmt;
  }

  public int insert(
      String statement, Object[] args, FieldType[] argFieldTypes, GeneratedKeyHolder keyHolder)
      throws SQLException {
    SQLiteStatement stmt = null;
    try {
      stmt = db.compileStatement(statement);
      bindArgs(stmt, args, argFieldTypes);
      long rowId = stmt.executeInsert();
      if (keyHolder != null) {
        keyHolder.addKey(rowId);
      }
      /*
       * I've decided to not do the CHANGES() statement here like we do down below in UPDATE because we know that
       * it worked (since it didn't throw) so we know that 1 is right.
       */
      int result = 1;
      logger.trace(
          "{}: insert statement is compiled and executed, changed {}: {}", this, result, statement);
      return result;
    } catch (android.database.SQLException e) {
      throw SqlExceptionUtil.create("inserting to database failed: " + statement, e);
    } finally {
      closeQuietly(stmt);
    }
  }

  public int update(String statement, Object[] args, FieldType[] argFieldTypes)
      throws SQLException {
    return update(statement, args, argFieldTypes, "updated");
  }

  public int delete(String statement, Object[] args, FieldType[] argFieldTypes)
      throws SQLException {
    // delete is the same as update
    return update(statement, args, argFieldTypes, "deleted");
  }

  public <T> Object queryForOne(
      String statement,
      Object[] args,
      FieldType[] argFieldTypes,
      GenericRowMapper<T> rowMapper,
      ObjectCache objectCache)
      throws SQLException {
    Cursor cursor = null;
    try {
      cursor = db.rawQuery(statement, toStrings(args));
      AndroidDatabaseResults results = new AndroidDatabaseResults(cursor, objectCache);
      logger.trace("{}: queried for one result: {}", this, statement);
      if (!results.first()) {
        return null;
      } else {
        T first = rowMapper.mapRow(results);
        if (results.next()) {
          return MORE_THAN_ONE;
        } else {
          return first;
        }
      }
    } catch (android.database.SQLException e) {
      throw SqlExceptionUtil.create("queryForOne from database failed: " + statement, e);
    } finally {
      closeQuietly(cursor);
    }
  }

  public long queryForLong(String statement) throws SQLException {
    SQLiteStatement stmt = null;
    try {
      stmt = db.compileStatement(statement);
      long result = stmt.simpleQueryForLong();
      logger.trace("{}: query for long simple query returned {}: {}", this, result, statement);
      return result;
    } catch (android.database.SQLException e) {
      throw SqlExceptionUtil.create("queryForLong from database failed: " + statement, e);
    } finally {
      closeQuietly(stmt);
    }
  }

  public long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes)
      throws SQLException {
    Cursor cursor = null;
    AndroidDatabaseResults results = null;
    try {
      cursor = db.rawQuery(statement, toStrings(args));
      results = new AndroidDatabaseResults(cursor, null);
      long result;
      if (results.first()) {
        result = results.getLong(0);
      } else {
        result = 0L;
      }
      logger.trace("{}: query for long raw query returned {}: {}", this, result, statement);
      return result;
    } catch (android.database.SQLException e) {
      throw SqlExceptionUtil.create("queryForLong from database failed: " + statement, e);
    } finally {
      closeQuietly(cursor);
      IOUtils.closeQuietly(results);
    }
  }

  public void close() throws IOException {
    try {
      db.close();
      logger.trace("{}: db {} closed", this, db);
    } catch (android.database.SQLException e) {
      throw new IOException("problems closing the database connection", e);
    }
  }

  public void closeQuietly() {
    IOUtils.closeQuietly(this);
  }

  public boolean isClosed() throws SQLException {
    try {
      boolean isOpen = db.isOpen();
      logger.trace("{}: db {} isOpen returned {}", this, db, isOpen);
      return !isOpen;
    } catch (android.database.SQLException e) {
      throw SqlExceptionUtil.create("problems detecting if the database is closed", e);
    }
  }

  public boolean isTableExists(String tableName) {
    Cursor cursor =
        db.rawQuery(
            "SELECT DISTINCT tbl_name FROM sqlite_master WHERE tbl_name = '" + tableName + "'",
            null);
    try {
      boolean result;
      if (cursor.getCount() > 0) {
        result = true;
      } else {
        result = false;
      }
      logger.trace("{}: isTableExists '{}' returned {}", this, tableName, result);
      return result;
    } finally {
      cursor.close();
    }
  }

  private int update(String statement, Object[] args, FieldType[] argFieldTypes, String label)
      throws SQLException {
    SQLiteStatement stmt = null;
    try {
      stmt = db.compileStatement(statement);
      bindArgs(stmt, args, argFieldTypes);
      stmt.execute();
    } catch (android.database.SQLException e) {
      throw SqlExceptionUtil.create("updating database failed: " + statement, e);
    } finally {
      closeQuietly(stmt);
      stmt = null;
    }
    int result;
    try {
      stmt = db.compileStatement("SELECT CHANGES()");
      result = (int) stmt.simpleQueryForLong();
    } catch (android.database.SQLException e) {
      // ignore the exception and just return 1
      result = 1;
    } finally {
      closeQuietly(stmt);
    }
    logger.trace("{} statement is compiled and executed, changed {}: {}", label, result, statement);
    return result;
  }

  private void bindArgs(SQLiteStatement stmt, Object[] args, FieldType[] argFieldTypes)
      throws SQLException {
    if (args == null) {
      return;
    }
    for (int i = 0; i < args.length; i++) {
      Object arg = args[i];
      if (arg == null) {
        stmt.bindNull(i + 1);
      } else {
        SqlType sqlType = argFieldTypes[i].getSqlType();
        switch (sqlType) {
          case STRING:
          case LONG_STRING:
          case CHAR:
            stmt.bindString(i + 1, arg.toString());
            break;
          case BOOLEAN:
          case BYTE:
          case SHORT:
          case INTEGER:
          case LONG:
            stmt.bindLong(i + 1, ((Number) arg).longValue());
            break;
          case FLOAT:
          case DOUBLE:
            stmt.bindDouble(i + 1, ((Number) arg).doubleValue());
            break;
          case BYTE_ARRAY:
          case SERIALIZABLE:
            stmt.bindBlob(i + 1, (byte[]) arg);
            break;
          case DATE:
            // this is mapped to a STRING under Android
          case BLOB:
            // this is only for derby serializable
          case BIG_DECIMAL:
            // this should be handled as a STRING
            throw new SQLException("Invalid Android type: " + sqlType);
          case UNKNOWN:
          default:
            throw new SQLException("Unknown sql argument type: " + sqlType);
        }
      }
    }
  }

  private String[] toStrings(Object[] args) {
    if (args == null || args.length == 0) {
      return null;
    }
    String[] strings = new String[args.length];
    for (int i = 0; i < args.length; i++) {
      Object arg = args[i];
      if (arg == null) {
        strings[i] = null;
      } else {
        strings[i] = arg.toString();
      }
    }

    return strings;
  }

  @Override
  public String toString() {
    return getClass().getSimpleName() + "@" + Integer.toHexString(super.hashCode());
  }

  /** We can't use IOUtils here because older versions didn't implement Closeable. */
  private void closeQuietly(Cursor cursor) {
    if (cursor != null) {
      cursor.close();
    }
  }

  /** We can't use IOUtils here because older versions didn't implement Closeable. */
  private void closeQuietly(SQLiteStatement statement) {
    if (statement != null) {
      statement.close();
    }
  }

  private static class OurSavePoint implements Savepoint {

    private String name;

    public OurSavePoint(String name) {
      this.name = name;
    }

    public int getSavepointId() {
      return 0;
    }

    public String getSavepointName() {
      return name;
    }
  }
}
/**
 * Proxy to a {@link Dao} that wraps each Exception and rethrows it as RuntimeException. You can use
 * this if your usage pattern is to ignore all exceptions. That's not a pattern that I like so it's
 * not the default.
 *
 * <pre>
 * RuntimeExceptionDao&lt;Account, String&gt; accountDao = RuntimeExceptionDao.createDao(connectionSource, Account.class);
 * </pre>
 *
 * @author graywatson
 */
public class RuntimeExceptionDao<T, ID> implements CloseableIterable<T> {

  /*
   * We use debug here because we don't want these messages to be logged by default. The user will need to turn on
   * logging for this class to DEBUG to see the messages.
   */
  private static final Level LOG_LEVEL = Level.DEBUG;

  private Dao<T, ID> dao;
  private static final Logger logger = LoggerFactory.getLogger(RuntimeExceptionDao.class);

  public RuntimeExceptionDao(Dao<T, ID> dao) {
    this.dao = dao;
  }

  /**
   * Call through to {@link DaoManager#createDao(ConnectionSource, Class)} with the returned DAO
   * wrapped in a RuntimeExceptionDao.
   */
  public static <T, ID> RuntimeExceptionDao<T, ID> createDao(
      ConnectionSource connectionSource, Class<T> clazz) throws SQLException {
    @SuppressWarnings("unchecked")
    Dao<T, ID> castDao = (Dao<T, ID>) DaoManager.createDao(connectionSource, clazz);
    return new RuntimeExceptionDao<T, ID>(castDao);
  }

  /**
   * Call through to {@link DaoManager#createDao(ConnectionSource, DatabaseTableConfig)} with the
   * returned DAO wrapped in a RuntimeExceptionDao.
   */
  public static <T, ID> RuntimeExceptionDao<T, ID> createDao(
      ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig) throws SQLException {
    @SuppressWarnings("unchecked")
    Dao<T, ID> castDao = (Dao<T, ID>) DaoManager.createDao(connectionSource, tableConfig);
    return new RuntimeExceptionDao<T, ID>(castDao);
  }

  /** @see Dao#queryForId(Object) */
  public T queryForId(ID id) {
    try {
      return dao.queryForId(id);
    } catch (SQLException e) {
      logMessage(e, "queryForId threw exception on: " + id);
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#queryForFirst(PreparedQuery) */
  public T queryForFirst(PreparedQuery<T> preparedQuery) {
    try {
      return dao.queryForFirst(preparedQuery);
    } catch (SQLException e) {
      logMessage(e, "queryForFirst threw exception on: " + preparedQuery);
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#queryForAll() */
  public List<T> queryForAll() {
    try {
      return dao.queryForAll();
    } catch (SQLException e) {
      logMessage(e, "queryForAll threw exception");
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#queryForEq(String, Object) */
  public List<T> queryForEq(String fieldName, Object value) {
    try {
      return dao.queryForEq(fieldName, value);
    } catch (SQLException e) {
      logMessage(e, "queryForEq threw exception on: " + fieldName);
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#queryForMatching(Object) */
  public List<T> queryForMatching(T matchObj) {
    try {
      return dao.queryForMatching(matchObj);
    } catch (SQLException e) {
      logMessage(e, "queryForMatching threw exception on: " + matchObj);
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#queryForMatchingArgs(Object) */
  public List<T> queryForMatchingArgs(T matchObj) {
    try {
      return dao.queryForMatchingArgs(matchObj);
    } catch (SQLException e) {
      logMessage(e, "queryForMatchingArgs threw exception on: " + matchObj);
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#queryForFieldValues(Map) */
  public List<T> queryForFieldValues(Map<String, Object> fieldValues) {
    try {
      return dao.queryForFieldValues(fieldValues);
    } catch (SQLException e) {
      logMessage(e, "queryForFieldValues threw exception");
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#queryForFieldValuesArgs(Map) */
  public List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues) {
    try {
      return dao.queryForFieldValuesArgs(fieldValues);
    } catch (SQLException e) {
      logMessage(e, "queryForFieldValuesArgs threw exception");
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#queryForSameId(Object) */
  public T queryForSameId(T data) {
    try {
      return dao.queryForSameId(data);
    } catch (SQLException e) {
      logMessage(e, "queryForSameId threw exception on: " + data);
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#queryBuilder() */
  public QueryBuilder<T, ID> queryBuilder() {
    return dao.queryBuilder();
  }

  /** @see Dao#updateBuilder() */
  public UpdateBuilder<T, ID> updateBuilder() {
    return dao.updateBuilder();
  }

  /** @see Dao#deleteBuilder() */
  public DeleteBuilder<T, ID> deleteBuilder() {
    return dao.deleteBuilder();
  }

  /** @see Dao#query(PreparedQuery) */
  public List<T> query(PreparedQuery<T> preparedQuery) {
    try {
      return dao.query(preparedQuery);
    } catch (SQLException e) {
      logMessage(e, "query threw exception on: " + preparedQuery);
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#create(Object) */
  public int create(T data) {
    try {
      return dao.create(data);
    } catch (SQLException e) {
      logMessage(e, "create threw exception on: " + data);
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#create(Collection) */
  public int create(Collection<T> datas) {
    try {
      return dao.create(datas);
    } catch (SQLException e) {
      logMessage(e, "create threw exception on: " + datas);
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#createIfNotExists(Object) */
  public T createIfNotExists(T data) {
    try {
      return dao.createIfNotExists(data);
    } catch (SQLException e) {
      logMessage(e, "createIfNotExists threw exception on: " + data);
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#createOrUpdate(Object) */
  public CreateOrUpdateStatus createOrUpdate(T data) {
    try {
      return dao.createOrUpdate(data);
    } catch (SQLException e) {
      logMessage(e, "createOrUpdate threw exception on: " + data);
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#update(Object) */
  public int update(T data) {
    try {
      return dao.update(data);
    } catch (SQLException e) {
      logMessage(e, "update threw exception on: " + data);
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#updateId(Object, Object) */
  public int updateId(T data, ID newId) {
    try {
      return dao.updateId(data, newId);
    } catch (SQLException e) {
      logMessage(e, "updateId threw exception on: " + data);
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#update(PreparedUpdate) */
  public int update(PreparedUpdate<T> preparedUpdate) {
    try {
      return dao.update(preparedUpdate);
    } catch (SQLException e) {
      logMessage(e, "update threw exception on: " + preparedUpdate);
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#refresh(Object) */
  public int refresh(T data) {
    try {
      return dao.refresh(data);
    } catch (SQLException e) {
      logMessage(e, "refresh threw exception on: " + data);
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#delete(Object) */
  public int delete(T data) {
    try {
      return dao.delete(data);
    } catch (SQLException e) {
      logMessage(e, "delete threw exception on: " + data);
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#deleteById(Object) */
  public int deleteById(ID id) {
    try {
      return dao.deleteById(id);
    } catch (SQLException e) {
      logMessage(e, "deleteById threw exception on: " + id);
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#delete(Collection) */
  public int delete(Collection<T> datas) {
    try {
      return dao.delete(datas);
    } catch (SQLException e) {
      logMessage(e, "delete threw exception on: " + datas);
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#deleteIds(Collection) */
  public int deleteIds(Collection<ID> ids) {
    try {
      return dao.deleteIds(ids);
    } catch (SQLException e) {
      logMessage(e, "deleteIds threw exception on: " + ids);
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#delete(PreparedDelete) */
  public int delete(PreparedDelete<T> preparedDelete) {
    try {
      return dao.delete(preparedDelete);
    } catch (SQLException e) {
      logMessage(e, "delete threw exception on: " + preparedDelete);
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#iterator() */
  public CloseableIterator<T> iterator() {
    return dao.iterator();
  }

  public CloseableIterator<T> closeableIterator() {
    return dao.closeableIterator();
  }

  /** @see Dao#iterator(int) */
  public CloseableIterator<T> iterator(int resultFlags) {
    return dao.iterator(resultFlags);
  }

  /** @see Dao#getWrappedIterable() */
  public CloseableWrappedIterable<T> getWrappedIterable() {
    return dao.getWrappedIterable();
  }

  /** @see Dao#getWrappedIterable(PreparedQuery) */
  public CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery) {
    return dao.getWrappedIterable(preparedQuery);
  }

  /** @see Dao#closeLastIterator() */
  public void closeLastIterator() {
    try {
      dao.closeLastIterator();
    } catch (IOException e) {
      logMessage(e, "closeLastIterator threw exception");
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#iterator(PreparedQuery) */
  public CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery) {
    try {
      return dao.iterator(preparedQuery);
    } catch (SQLException e) {
      logMessage(e, "iterator threw exception on: " + preparedQuery);
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#iterator(PreparedQuery, int) */
  public CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags) {
    try {
      return dao.iterator(preparedQuery, resultFlags);
    } catch (SQLException e) {
      logMessage(e, "iterator threw exception on: " + preparedQuery);
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#queryRaw(String, String...) */
  public GenericRawResults<String[]> queryRaw(String query, String... arguments) {
    try {
      return dao.queryRaw(query, arguments);
    } catch (SQLException e) {
      logMessage(e, "queryRaw threw exception on: " + query);
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#queryRawValue(String, String...) */
  public long queryRawValue(String query, String... arguments) {
    try {
      return dao.queryRawValue(query, arguments);
    } catch (SQLException e) {
      logMessage(e, "queryRawValue threw exception on: " + query);
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#queryRaw(String, RawRowMapper, String...) */
  public <UO> GenericRawResults<UO> queryRaw(
      String query, RawRowMapper<UO> mapper, String... arguments) {
    try {
      return dao.queryRaw(query, mapper, arguments);
    } catch (SQLException e) {
      logMessage(e, "queryRaw threw exception on: " + query);
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#queryRaw(String, DataType[], RawRowObjectMapper, String...) */
  public <UO> GenericRawResults<UO> queryRaw(
      String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper, String... arguments) {
    try {
      return dao.queryRaw(query, columnTypes, mapper, arguments);
    } catch (SQLException e) {
      logMessage(e, "queryRaw threw exception on: " + query);
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#queryRaw(String, DataType[], String...) */
  public GenericRawResults<Object[]> queryRaw(
      String query, DataType[] columnTypes, String... arguments) {
    try {
      return dao.queryRaw(query, columnTypes, arguments);
    } catch (SQLException e) {
      logMessage(e, "queryRaw threw exception on: " + query);
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#queryRaw(String, DatabaseResultsMapper, String...) */
  public <UO> GenericRawResults<UO> queryRaw(
      String query, DatabaseResultsMapper<UO> mapper, String... arguments) {
    try {
      return dao.queryRaw(query, mapper, arguments);
    } catch (SQLException e) {
      logMessage(e, "queryRaw threw exception on: " + query);
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#executeRaw(String, String...) */
  public int executeRaw(String statement, String... arguments) {
    try {
      return dao.executeRaw(statement, arguments);
    } catch (SQLException e) {
      logMessage(e, "executeRaw threw exception on: " + statement);
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#executeRawNoArgs(String) */
  public int executeRawNoArgs(String statement) {
    try {
      return dao.executeRawNoArgs(statement);
    } catch (SQLException e) {
      logMessage(e, "executeRawNoArgs threw exception on: " + statement);
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#updateRaw(String, String...) */
  public int updateRaw(String statement, String... arguments) {
    try {
      return dao.updateRaw(statement, arguments);
    } catch (SQLException e) {
      logMessage(e, "updateRaw threw exception on: " + statement);
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#callBatchTasks(Callable) */
  public <CT> CT callBatchTasks(Callable<CT> callable) {
    try {
      return dao.callBatchTasks(callable);
    } catch (Exception e) {
      logMessage(e, "callBatchTasks threw exception on: " + callable);
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#objectToString(Object) */
  public String objectToString(T data) {
    return dao.objectToString(data);
  }

  /** @see Dao#objectsEqual(Object, Object) */
  public boolean objectsEqual(T data1, T data2) {
    try {
      return dao.objectsEqual(data1, data2);
    } catch (SQLException e) {
      logMessage(e, "objectsEqual threw exception on: " + data1 + " and " + data2);
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#extractId(Object) */
  public ID extractId(T data) {
    try {
      return dao.extractId(data);
    } catch (SQLException e) {
      logMessage(e, "extractId threw exception on: " + data);
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#getDataClass() */
  public Class<T> getDataClass() {
    return dao.getDataClass();
  }

  /** @see Dao#findForeignFieldType(Class) */
  public FieldType findForeignFieldType(Class<?> clazz) {
    return dao.findForeignFieldType(clazz);
  }

  /** @see Dao#isUpdatable() */
  public boolean isUpdatable() {
    return dao.isUpdatable();
  }

  /** @see Dao#isTableExists() */
  public boolean isTableExists() {
    try {
      return dao.isTableExists();
    } catch (SQLException e) {
      logMessage(e, "isTableExists threw exception");
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#countOf() */
  public long countOf() {
    try {
      return dao.countOf();
    } catch (SQLException e) {
      logMessage(e, "countOf threw exception");
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#countOf(PreparedQuery) */
  public long countOf(PreparedQuery<T> preparedQuery) {
    try {
      return dao.countOf(preparedQuery);
    } catch (SQLException e) {
      logMessage(e, "countOf threw exception on " + preparedQuery);
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#assignEmptyForeignCollection(Object, String) */
  public void assignEmptyForeignCollection(T parent, String fieldName) {
    try {
      dao.assignEmptyForeignCollection(parent, fieldName);
    } catch (SQLException e) {
      logMessage(e, "assignEmptyForeignCollection threw exception on " + fieldName);
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#getEmptyForeignCollection(String) */
  public <FT> ForeignCollection<FT> getEmptyForeignCollection(String fieldName) {
    try {
      return dao.getEmptyForeignCollection(fieldName);
    } catch (SQLException e) {
      logMessage(e, "getEmptyForeignCollection threw exception on " + fieldName);
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#setObjectCache(boolean) */
  public void setObjectCache(boolean enabled) {
    try {
      dao.setObjectCache(enabled);
    } catch (SQLException e) {
      logMessage(e, "setObjectCache(" + enabled + ") threw exception");
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#getObjectCache() */
  public ObjectCache getObjectCache() {
    return dao.getObjectCache();
  }

  /** @see Dao#setObjectCache(ObjectCache) */
  public void setObjectCache(ObjectCache objectCache) {
    try {
      dao.setObjectCache(objectCache);
    } catch (SQLException e) {
      logMessage(e, "setObjectCache threw exception on " + objectCache);
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#clearObjectCache() */
  public void clearObjectCache() {
    dao.clearObjectCache();
  }

  /** @see Dao#mapSelectStarRow(DatabaseResults) */
  public T mapSelectStarRow(DatabaseResults results) {
    try {
      return dao.mapSelectStarRow(results);
    } catch (SQLException e) {
      logMessage(e, "mapSelectStarRow threw exception on results");
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#getSelectStarRowMapper() */
  public GenericRowMapper<T> getSelectStarRowMapper() {
    try {
      return dao.getSelectStarRowMapper();
    } catch (SQLException e) {
      logMessage(e, "getSelectStarRowMapper threw exception");
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#idExists(Object) */
  public boolean idExists(ID id) {
    try {
      return dao.idExists(id);
    } catch (SQLException e) {
      logMessage(e, "idExists threw exception on " + id);
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#startThreadConnection() */
  public DatabaseConnection startThreadConnection() {
    try {
      return dao.startThreadConnection();
    } catch (SQLException e) {
      logMessage(e, "startThreadConnection() threw exception");
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#endThreadConnection(DatabaseConnection) */
  public void endThreadConnection(DatabaseConnection connection) {
    try {
      dao.endThreadConnection(connection);
    } catch (SQLException e) {
      logMessage(e, "endThreadConnection(" + connection + ") threw exception");
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#setAutoCommit(boolean) */
  @Deprecated
  public void setAutoCommit(boolean autoCommit) {
    try {
      dao.setAutoCommit(autoCommit);
    } catch (SQLException e) {
      logMessage(e, "setAutoCommit(" + autoCommit + ") threw exception");
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#setAutoCommit(DatabaseConnection, boolean) */
  public void setAutoCommit(DatabaseConnection connection, boolean autoCommit) {
    try {
      dao.setAutoCommit(connection, autoCommit);
    } catch (SQLException e) {
      logMessage(e, "setAutoCommit(" + connection + "," + autoCommit + ") threw exception");
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#isAutoCommit() */
  @Deprecated
  public boolean isAutoCommit() {
    try {
      return dao.isAutoCommit();
    } catch (SQLException e) {
      logMessage(e, "isAutoCommit() threw exception");
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#isAutoCommit(DatabaseConnection) */
  public boolean isAutoCommit(DatabaseConnection connection) {
    try {
      return dao.isAutoCommit(connection);
    } catch (SQLException e) {
      logMessage(e, "isAutoCommit(" + connection + ") threw exception");
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#commit(DatabaseConnection) */
  public void commit(DatabaseConnection connection) {
    try {
      dao.commit(connection);
    } catch (SQLException e) {
      logMessage(e, "commit(" + connection + ") threw exception");
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#rollBack(DatabaseConnection) */
  public void rollBack(DatabaseConnection connection) {
    try {
      dao.rollBack(connection);
    } catch (SQLException e) {
      logMessage(e, "rollBack(" + connection + ") threw exception");
      throw new RuntimeException(e);
    }
  }

  /** @see Dao#setObjectFactory(ObjectFactory) */
  public void setObjectFactory(ObjectFactory<T> objectFactory) {
    dao.setObjectFactory(objectFactory);
  }

  /** @see Dao#getRawRowMapper() */
  public RawRowMapper<T> getRawRowMapper() {
    return dao.getRawRowMapper();
  }

  /** @see Dao#getConnectionSource() */
  public ConnectionSource getConnectionSource() {
    return dao.getConnectionSource();
  }

  public void registerObserver(DaoObserver observer) {
    dao.registerObserver(observer);
  }

  public void unregisterObserver(DaoObserver observer) {
    dao.unregisterObserver(observer);
  }

  public void notifyChanges() {
    dao.notifyChanges();
  }

  private void logMessage(Exception e, String message) {
    logger.log(LOG_LEVEL, e, message);
  }
}
public class AndroidConnectionSource extends BaseConnectionSource implements ConnectionSource {

  private static final Logger logger =
      LoggerFactory.getLogger(com / j256 / ormlite / android / AndroidConnectionSource);
  private AndroidDatabaseConnection connection;
  private final DatabaseType databaseType;
  private final SQLiteOpenHelper helper;
  private volatile boolean isOpen;
  private final SQLiteDatabase sqliteDatabase;

  public AndroidConnectionSource(SQLiteDatabase sqlitedatabase) {
    connection = null;
    isOpen = true;
    databaseType = new SqliteAndroidDatabaseType();
    helper = null;
    sqliteDatabase = sqlitedatabase;
  }

  public AndroidConnectionSource(SQLiteOpenHelper sqliteopenhelper) {
    connection = null;
    isOpen = true;
    databaseType = new SqliteAndroidDatabaseType();
    helper = sqliteopenhelper;
    sqliteDatabase = null;
  }

  public void clearSpecialConnection(DatabaseConnection databaseconnection) {
    clearSpecial(databaseconnection, logger);
  }

  public void close() {
    isOpen = false;
  }

  public DatabaseType getDatabaseType() {
    return databaseType;
  }

  public DatabaseConnection getReadOnlyConnection() {
    return getReadWriteConnection();
  }

  public DatabaseConnection getReadWriteConnection() {
    DatabaseConnection databaseconnection = getSavedConnection();
    if (databaseconnection != null) {
      return databaseconnection;
    }
    if (connection == null) {
      if (sqliteDatabase == null) {
        connection = new AndroidDatabaseConnection(helper.getWritableDatabase(), true);
      } else {
        connection = new AndroidDatabaseConnection(sqliteDatabase, true);
      }
    }
    return connection;
  }

  public boolean isOpen() {
    return isOpen;
  }

  public void releaseConnection(DatabaseConnection databaseconnection) {}

  public boolean saveSpecialConnection(DatabaseConnection databaseconnection) {
    return saveSpecial(databaseconnection);
  }
}
/**
 * This helps organize and access database connections to optimize connection sharing. There are
 * several schemes to manage the database connections in an Android app, but as an app gets more
 * complicated, there are many potential places where database locks can occur. This class allows
 * database connection sharing between multiple threads in a single app.
 *
 * <p>This gets injected or called with the {@link OrmLiteSqliteOpenHelper} class that is used to
 * manage the database connection. The helper instance will be kept in a static field and only
 * released once its internal usage count goes to 0.
 *
 * <p>The {@link SQLiteOpenHelper} and database classes maintain one connection under the hood, and
 * prevent locks in the java code. Creating multiple connections can potentially be a source of
 * trouble. This class shares the same connection instance between multiple clients, which will
 * allow multiple activities and services to run at the same time.
 *
 * <p>Every time you use the helper, you should call {@link #getHelper(Context)} or {@link
 * #getHelper(Context, Class)}. When you are done with the helper you should call {@link
 * #releaseHelper()}.
 *
 * @author graywatson, kevingalligan
 */
public class OpenHelperManager {

  private static final String HELPER_CLASS_RESOURCE_NAME = "open_helper_classname";
  private static Logger logger = LoggerFactory.getLogger(OpenHelperManager.class);

  private static Class<? extends OrmLiteSqliteOpenHelper> helperClass = null;
  private static volatile OrmLiteSqliteOpenHelper helper = null;
  private static boolean wasClosed = false;
  private static int instanceCount = 0;

  /**
   * If you are _not_ using the {@link OrmLiteBaseActivity} type classes then you will need to call
   * this in a static method in your code.
   */
  public static synchronized void setOpenHelperClass(
      Class<? extends OrmLiteSqliteOpenHelper> openHelperClass) {
    if (openHelperClass == null) {
      helperClass = null;
    } else {
      innerSetHelperClass(openHelperClass);
    }
  }

  /**
   * Set the helper for the manager. This is most likely used for testing purposes and should only
   * be called if you _really_ know what you are doing. If you do use it then it should be in a
   * static {} initializing block to make sure you have one helper instance for your application.
   */
  public static synchronized void setHelper(OrmLiteSqliteOpenHelper helper) {
    OpenHelperManager.helper = helper;
  }

  /**
   * Create a static instance of our open helper from the helper class. This has a usage counter on
   * it so make sure all calls to this method have an associated call to {@link #releaseHelper()}.
   * This should be called during an onCreate() type of method when the application or service is
   * starting. The caller should then keep the helper around until it is shutting down when {@link
   * #releaseHelper()} should be called.
   */
  public static synchronized <T extends OrmLiteSqliteOpenHelper> T getHelper(
      Context context, Class<T> openHelperClass) {
    innerSetHelperClass(openHelperClass);
    return loadHelper(context, openHelperClass);
  }

  /**
   * Similar to {@link #getHelper(Context, Class)} (which is recommended) except we have to find the
   * helper class through other means. This method requires that the Context be a class that extends
   * one of ORMLite's Android base classes such as {@link OrmLiteBaseActivity}. Either that or the
   * helper class needs to be set in the strings.xml.
   *
   * <p>To find the helper class, this does the following: <br>
   * 1) If the class has been set with a call to {@link #setOpenHelperClass(Class)}, it will be used
   * to construct a helper. <br>
   * 2) If the resource class name is configured in the strings.xml file it will be used. <br>
   * 3) The context class hierarchy is walked looking at the generic parameters for a class
   * extending OrmLiteSqliteOpenHelper. This is used by the {@link OrmLiteBaseActivity} and other
   * base classes. <br>
   * 4) An exception is thrown saying that it was not able to set the helper class.
   *
   * @deprecated Should use {@link #getHelper(Context, Class)}
   */
  @Deprecated
  public static synchronized OrmLiteSqliteOpenHelper getHelper(Context context) {
    if (helperClass == null) {
      if (context == null) {
        throw new IllegalArgumentException("context argument is null");
      }
      Context appContext = context.getApplicationContext();
      innerSetHelperClass(lookupHelperClass(appContext, context.getClass()));
    }
    return loadHelper(context, helperClass);
  }

  /** @deprecated This has been renamed to be {@link #releaseHelper()}. */
  @Deprecated
  public static void release() {
    releaseHelper();
  }

  /**
   * Release the helper that was previously returned by a call {@link #getHelper(Context)} or {@link
   * #getHelper(Context, Class)}. This will decrement the usage counter and close the helper if the
   * counter is 0.
   *
   * <p><b> WARNING: </b> This should be called in an onDestroy() type of method when your
   * application or service is terminating or if your code is no longer going to use the helper or
   * derived DAOs in any way. _Don't_ call this method if you expect to call {@link
   * #getHelper(Context)} again before the application terminates.
   */
  public static synchronized void releaseHelper() {
    instanceCount--;
    logger.trace("releasing helper {}, instance count = {}", helper, instanceCount);
    if (instanceCount <= 0) {
      if (helper != null) {
        logger.trace("zero instances, closing helper {}", helper);
        helper.close();
        helper = null;
        wasClosed = true;
      }
      if (instanceCount < 0) {
        logger.error("too many calls to release helper, instance count = {}", instanceCount);
      }
    }
  }

  /** Set the helper class and make sure we aren't changing it to another class. */
  private static void innerSetHelperClass(
      Class<? extends OrmLiteSqliteOpenHelper> openHelperClass) {
    // make sure if that there are not 2 helper classes in an application
    if (helperClass == null) {
      helperClass = openHelperClass;
    } else if (helperClass != openHelperClass) {
      throw new IllegalStateException(
          "Helper class was " + helperClass + " but is trying to be reset to " + openHelperClass);
    }
  }

  private static <T extends OrmLiteSqliteOpenHelper> T loadHelper(
      Context context, Class<T> openHelperClass) {
    if (helper == null) {
      if (wasClosed) {
        // this can happen if you are calling get/release and then get again
        logger.info("helper was already closed and is being re-opened");
      }
      if (context == null) {
        throw new IllegalArgumentException("context argument is null");
      }
      Context appContext = context.getApplicationContext();
      helper = constructHelper(appContext, helperClass);
      logger.trace("zero instances, created helper {}", helper);
      /*
       * Filipe Leandro and I worked on this bug for like 10 hours straight. It's a doosey.
       *
       * Each ForeignCollection has internal DAO objects that are holding a ConnectionSource. Each Android
       * ConnectionSource is tied to a particular database connection. What Filipe was seeing was that when all of
       * his views we closed (onDestroy), but his application WAS NOT FULLY KILLED, the first View.onCreate()
       * method would open a new connection to the database. Fine. But because he application was still in memory,
       * the static BaseDaoImpl default cache had not been cleared and was containing cached objects with
       * ForeignCollections. The ForeignCollections still had references to the DAOs that had been opened with old
       * ConnectionSource objects and therefore the old database connection. Using those cached collections would
       * cause exceptions saying that you were trying to work with a database that had already been close.
       *
       * Now, whenever we create a new helper object, we must make sure that the internal object caches have been
       * fully cleared. This is a good lesson for anyone that is holding objects around after they have closed
       * connections to the database or re-created the DAOs on a different connection somehow.
       */
      BaseDaoImpl.clearAllInternalObjectCaches();
      /*
       * Might as well do this also since if the helper changes then the ConnectionSource will change so no one is
       * going to have a cache hit on the old DAOs anyway. All they are doing is holding memory.
       *
       * NOTE: we don't want to clear the config map.
       */
      DaoManager.clearDaoCache();
      instanceCount = 0;
    }

    instanceCount++;
    logger.trace("returning helper {}, instance count = {} ", helper, instanceCount);
    @SuppressWarnings("unchecked")
    T castHelper = (T) helper;
    return castHelper;
  }

  /** Call the constructor on our helper class. */
  private static OrmLiteSqliteOpenHelper constructHelper(
      Context context, Class<? extends OrmLiteSqliteOpenHelper> openHelperClass) {
    Constructor<?> constructor;
    try {
      constructor = openHelperClass.getConstructor(Context.class);
    } catch (Exception e) {
      throw new IllegalStateException(
          "Could not find constructor that hast just a (Context) argument for helper class "
              + openHelperClass,
          e);
    }
    try {
      return (OrmLiteSqliteOpenHelper) constructor.newInstance(context);
    } catch (Exception e) {
      throw new IllegalStateException(
          "Could not construct instance of helper class " + openHelperClass, e);
    }
  }

  /**
   * Lookup the helper class either from the resource string or by looking for a generic parameter.
   */
  private static Class<? extends OrmLiteSqliteOpenHelper> lookupHelperClass(
      Context context, Class<?> componentClass) {

    // see if we have the magic resource class name set
    Resources resources = context.getResources();
    int resourceId =
        resources.getIdentifier(HELPER_CLASS_RESOURCE_NAME, "string", context.getPackageName());
    if (resourceId != 0) {
      String className = resources.getString(resourceId);
      try {
        @SuppressWarnings("unchecked")
        Class<? extends OrmLiteSqliteOpenHelper> castClass =
            (Class<? extends OrmLiteSqliteOpenHelper>) Class.forName(className);
        return castClass;
      } catch (Exception e) {
        throw new IllegalStateException(
            "Could not create helper instance for class " + className, e);
      }
    }

    // try walking the context class to see if we can get the OrmLiteSqliteOpenHelper from a generic
    // parameter
    for (Class<?> componentClassWalk = componentClass;
        componentClassWalk != null;
        componentClassWalk = componentClassWalk.getSuperclass()) {
      Type superType = componentClassWalk.getGenericSuperclass();
      if (superType == null || !(superType instanceof ParameterizedType)) {
        continue;
      }
      // get the generic type arguments
      Type[] types = ((ParameterizedType) superType).getActualTypeArguments();
      // defense
      if (types == null || types.length == 0) {
        continue;
      }
      for (Type type : types) {
        // defense
        if (!(type instanceof Class)) {
          continue;
        }
        Class<?> clazz = (Class<?>) type;
        if (OrmLiteSqliteOpenHelper.class.isAssignableFrom(clazz)) {
          @SuppressWarnings("unchecked")
          Class<? extends OrmLiteSqliteOpenHelper> castOpenHelperClass =
              (Class<? extends OrmLiteSqliteOpenHelper>) clazz;
          return castOpenHelperClass;
        }
      }
    }
    throw new IllegalStateException(
        "Could not find OpenHelperClass because none of the generic parameters of class "
            + componentClass
            + " extends OrmLiteSqliteOpenHelper.  You should use getHelper(Context, Class) instead.");
  }
}