How to use

isOpen

method

in

android.database.sqlite.SQLiteDatabase

@Override
public boolean isOpen() {
  return delegate.isOpen();
}

/**
 * Close the database when reading data.
 *
 * @param database {@link SQLiteDatabase}.
 */
protected final void closeDateBase(SQLiteDatabase database) {
  if (database != null && database.isOpen())
    database.close();
}

 File dbfile = new File("/sdcard/mydb.sqlite" ); 
SQLiteDatabase db = SQLiteDatabase.openOrCreateDatabase(dbfile, null);
System.out.println("Its open? "  + db.isOpen());

protected final void closeDatabase(SQLiteDatabase database, Cursor cursor) {
  if (cursor != null && !cursor.isClosed()) cursor.close();
  if (database != null && database.isOpen()) database.close();
}

  public static boolean isFieldExists(SQLiteDatabase db, String tableName, String fieldName) {
    if (tableName == null || db == null || fieldName == null || !db.isOpen()) return false;

    Cursor cursor = null;
    try {
      cursor = db.rawQuery("SELECT * FROM " + tableName + " LIMIT 0", null);
      return cursor != null && cursor.getColumnIndex(fieldName) != -1;
    } catch (Exception e) {
      OkLogger.printStackTrace(e);
      return false;
    } finally {
      if (cursor != null) {
        cursor.close();
      }
    }
  }
}

/** Open the meta-db but only if it currently closed. */
private static void openDBIfClosed(Context context) {
  if (mMetaDb == null || !mMetaDb.isOpen()) {
    openDB(context);
  }
}

public SqliteDatabaseAssert isOpen() {
 isNotNull();
 assertThat(actual.isOpen()) //
   .overridingErrorMessage("Expected DB to be open but was not.") //
   .isTrue();
 return this;
}

@Test
public void testIsOpen() throws Exception {
  assertThat(database.isOpen()).isTrue();
  database.close();
  assertThat(database.isOpen()).isFalse();
}

@Test
public void shouldOpenExistingDatabaseFromFileSystemIfFileExists() throws Exception {
  database.close();
  SQLiteDatabase db = SQLiteDatabase.openDatabase(databasePath.getAbsolutePath(), null, OPEN_READWRITE);
  Cursor c = db.rawQuery("select * from rawtable", null);
  assertThat(c).isNotNull();
  assertThat(c.getCount()).isEqualTo(2);
  assertThat(db.isOpen()).isTrue();
  db.close();
  assertThat(db.isOpen()).isFalse();
  SQLiteDatabase reopened = SQLiteDatabase.openDatabase(databasePath.getAbsolutePath(), null, OPEN_READWRITE);
  assertThat(reopened).isNotSameAs(db);
  assertThat(reopened.isOpen()).isTrue();
}

@Test
public void testClose() throws Exception {
 SQLiteDatabase database = helper.getWritableDatabase();
 assertThat(database.isOpen()).isTrue();
 helper.close();
 assertThat(database.isOpen()).isFalse();
}

private static void assertDatabaseOpened(SQLiteDatabase database, TestOpenHelper helper) {
 assertThat(database).isNotNull();
 assertThat(database.isOpen()).isTrue();
 assertThat(helper.onOpenCalled).isTrue();
 assertThat(helper.onUpgradeCalled).isFalse();
}

@Test
public void testCloseMultipleDbs() throws Exception {
 TestOpenHelper helper2 =
   new TestOpenHelper(ApplicationProvider.getApplicationContext(), "path2", null, 1);
 SQLiteDatabase database1 = helper.getWritableDatabase();
 SQLiteDatabase database2 = helper2.getWritableDatabase();
 assertThat(database1.isOpen()).isTrue();
 assertThat(database2.isOpen()).isTrue();
 helper.close();
 assertThat(database1.isOpen()).isFalse();
 assertThat(database2.isOpen()).isTrue();
 helper2.close();
 assertThat(database2.isOpen()).isFalse();
}

  @Test
  public void verifyDeleteWhileOpening() {
    Context context = RuntimeEnvironment.application;

    String filePath = getClass().getResource("/databases/corrupted.db").getPath();
    final long originalLength = new File(filePath).length();

    assertThat(new File(filePath).exists()).isTrue();

    JobStorage jobStorage = new JobStorage(context, filePath);
    SQLiteDatabase database = jobStorage.getDatabase();

    assertThat(database).isNotNull();
    assertThat(database.isOpen()).isTrue();
    assertThat(originalLength).isNotEqualTo(new File(filePath).length());

    File databaseFile = new File(database.getPath());
    assertThat(databaseFile.exists()).isTrue();
    assertThat(databaseFile.isFile()).isTrue();
  }
}

@Test
public void shouldUseInMemoryDatabaseWhenCallingCreate() throws Exception {
  SQLiteDatabase db = SQLiteDatabase.create(null);
  assertThat(db.isOpen()).isTrue();
  assertThat(db.getPath()).isEqualTo(":memory:");
}

@Test
public void verifyDeleteAfterCorruptionWhileOpen() {
  Context context = RuntimeEnvironment.application;
  JobStorage jobStorage = new JobStorage(context);
  SQLiteDatabase database = jobStorage.getDatabase();
  assertThat(database).isNotNull();
  assertThat(database.isOpen()).isTrue();
  File file = new File(database.getPath());
  assertThat(file.exists()).isTrue();
  assertThat(file.isFile()).isTrue();
  new JobStorageDatabaseErrorHandler().onCorruption(database);
  assertThat(file.exists()).isFalse();
}

public void testShutdown() throws Exception {
  final TrayContentProvider provider = startupProvider();
  final SQLiteDatabase writableDatabase = provider.mUserDbHelper.getWritableDatabase();
  assertTrue(writableDatabase.isOpen());
  provider.shutdown();
  assertFalse(writableDatabase.isOpen());
}

@Test
public void verifyDeleteAfterCorruptionWhileClosed() {
  Context context = RuntimeEnvironment.application;
  JobStorage jobStorage = new JobStorage(context);
  SQLiteDatabase database = jobStorage.getDatabase();
  assertThat(database).isNotNull();
  assertThat(database.isOpen()).isTrue();
  File file = new File(database.getPath());
  assertThat(file.exists()).isTrue();
  assertThat(file.isFile()).isTrue();
  database.close();
  new JobStorageDatabaseErrorHandler().onCorruption(database);
  assertThat(file.exists()).isFalse();
}

@Test
public void verifyDeleteWithApi14() {
  Context context = RuntimeEnvironment.application;
  JobStorage jobStorage = new JobStorage(context);
  SQLiteDatabase database = jobStorage.getDatabase();
  assertThat(database).isNotNull();
  assertThat(database.isOpen()).isTrue();
  File file = new File(database.getPath());
  assertThat(file.exists()).isTrue();
  assertThat(file.isFile()).isTrue();
  new JobStorageDatabaseErrorHandler().deleteApi14(context, file);
  assertThat(file.exists()).isFalse();
}

@Test
public void testCloseThenOpen() throws Exception {
 final String TABLE_NAME1 = "fart";
 SQLiteDatabase db1 = helper.getWritableDatabase();
 setupTable(db1, TABLE_NAME1);
 insertData(db1, TABLE_NAME1, new int[]{1, 2});
 verifyData(db1, TABLE_NAME1, 2);
 db1.close();
 db1 = helper.getWritableDatabase();
 assertThat(db1.isOpen()).isTrue();
}

public TrayContentProvider startupProvider() {
  final TrayContentProvider provider = new TrayContentProvider();
  provider.attachInfo(getProviderMockContext(), getMockProviderInfo());
  assertTrue(provider.onCreate());
  assertTrue(provider.mUserDbHelper.getWritableDatabase().isOpen());
  return provider;
}