How to use androidx.sqlite.db

  /**
   * @return The full path to this database file.
   */
  public String getPath() {
    return mDatabase.getPath();
  }
}

public void executeMany(String sql, List<Object[]> list) {
  mMod = true;
  mDatabase.beginTransaction();
  try {
    for (Object[] o : list) {
      mDatabase.execSQL(sql, o);
    }
    mDatabase.setTransactionSuccessful();
  } finally {
    mDatabase.endTransaction();
  }
}

@Override
public void disableDatabaseWriteAheadLogging(SupportSQLiteDatabase db) {
  db.disableWriteAheadLogging();
}

/**
 * Open a database connection to an ".anki" SQLite file.
 */
public DB(String ankiFilename) {
  SupportSQLiteOpenHelper.Configuration configuration = SupportSQLiteOpenHelper.Configuration.builder(AnkiDroidApp.getInstance())
      .name(ankiFilename)
      .callback(getDBCallback())
      .build();
  SupportSQLiteOpenHelper helper = getSqliteOpenHelperFactory().create(configuration);
  mDatabase = helper.getWritableDatabase();
  // TODO: remove this once everyone has stopped using old AnkiDroid clients with WAL (API >= 16)
  CompatHelper.getCompat().disableDatabaseWriteAheadLogging(mDatabase);
  mDatabase.query("PRAGMA synchronous = 2", null);
  mMod = false;
}

@Override
public void disableDatabaseWriteAheadLogging(SupportSQLiteDatabase db) {
  db.query("PRAGMA journal_mode = DELETE", null);
}

/**
 * Closes a previously opened database connection.
 */
public void close() {
  try {
    mDatabase.close();
    Timber.d("Database %s closed = %s", mDatabase.getPath(), !mDatabase.isOpen());
  } catch (Exception e) {
    // The pre-framework requery API ate this exception, but the framework API exposes it.
    // We may want to propagate it in the future, but for now maintain the old API and log.
    Timber.e(e, "Failed to close database %s", this.getDatabase().getPath());
  }
}

/**
 * WARNING: This is a convenience method that splits SQL scripts into separate queries with semicolons (;) 
 * as the delimiter. Only use this method on internal functions where we can guarantee that the script does
 * not contain any non-statement-terminating semicolons.
 */
public void executeScript(String sql) {
  mMod = true;
  String[] queries = sql.split(";");
  for(String query : queries) {
    mDatabase.execSQL(query);
  }
}

/** insert must always be called via DB in order to mark the db as changed */
public long insert(String table, ContentValues values) {
  mMod = true;
  return getDatabase().insert(table, SQLiteDatabase.CONFLICT_NONE, values);
}

/** update must always be called via DB in order to mark the db as changed */
public int update(String table, ContentValues values, String whereClause, String[] whereArgs) {
  mMod = true;
  return getDatabase().update(table, SQLiteDatabase.CONFLICT_NONE, values, whereClause, whereArgs);
}

/**
 * @return Whether or not {@link Collection} and its child database are open.
 */
public boolean colIsOpen() {
  return mCollection != null && mCollection.getDb() != null &&
      mCollection.getDb().getDatabase() != null && mCollection.getDb().getDatabase().isOpen();
}

public long queryLongScalar(String query) {
  Cursor cursor = null;
  long scalar;
  try {
    cursor = mDatabase.query(query, null);
    if (!cursor.moveToNext()) {
      return 0;
    }
    scalar = cursor.getLong(0);
  } finally {
    if (cursor != null) {
      cursor.close();
    }
  }
  return scalar;
}

public void execute(String sql, Object[] object) {
  String s = sql.trim().toLowerCase(Locale.US);
  // mark modified?
  for (String mo : MOD_SQLS) {
    if (s.startsWith(mo)) {
      mMod = true;
      break;
    }
  }
  if (object == null) {
    this.getDatabase().execSQL(sql);
  } else {
    this.getDatabase().execSQL(sql, object);
  }
}

@Override
public void disableDatabaseWriteAheadLogging(SupportSQLiteDatabase db) {
  db.disableWriteAheadLogging();
}

  /** Send error message, but do not call super() which would delete the database */
  public void onCorruption(SupportSQLiteDatabase db) {
    Timber.e("The database has been corrupted: %s", db.getPath());
    AnkiDroidApp.sendExceptionReport(new RuntimeException("Database corrupted"), "DB.MyDbErrorHandler.onCorruption", "Db has been corrupted: " + db.getPath());
    CollectionHelper.getInstance().closeCollection(false);
    DatabaseErrorDialog.databaseCorruptFlag = true;
  }
}

public int queryScalar(String query, String[] selectionArgs) {
  Cursor cursor = null;
  int scalar;
  try {
    cursor = mDatabase.query(query, selectionArgs);
    if (!cursor.moveToNext()) {
      return 0;
    }
    scalar = cursor.getInt(0);
  } finally {
    if (cursor != null) {
      cursor.close();
    }
  }
  return scalar;
}

public String queryString(String query) throws SQLException {
  Cursor cursor = null;
  try {
    cursor = mDatabase.query(query, null);
    if (!cursor.moveToNext()) {
      throw new SQLException("No result for query: " + query);
    }
    return cursor.getString(0);
  } finally {
    if (cursor != null) {
      cursor.close();
    }
  }
}

public Pair<String, Integer> syncInfo(String fname) {
  Cursor cur = null;
  try {
    cur = mDb.getDatabase().query("select csum, dirty from media where fname=?", new String[] { fname });
    if (cur.moveToNext()) {
      String csum = cur.getString(0);
      int dirty = cur.getInt(1);
      return new Pair<>(csum, dirty);
    } else {
      return new Pair<>(null, 0);
    }
  } finally {
    if (cur != null) {
      cur.close();
    }
  }
}

cur = db.query(queryNewEaseCountForCurrentEase, null);
cur.moveToNext();

public CardIterator(SupportSQLiteDatabase db, int today, Deck deck) {
  this.today = today;
  this.deck = deck;
  long did = deck.getDid();
  String query;
  query = "SELECT id, due, ivl, factor, type, reps " +
      "FROM cards " +
      "WHERE did IN (" + did + ") " +
      "order by id;";
  Timber.d("Forecast query: %s", query);
  cur = db.query(query, null);
}

public TodayStats(SupportSQLiteDatabase db, long dayStartCutoff) {
  Cursor cur = null;
  String query = "select cards.did, "+
      "sum(case when revlog.type = 0 then 1 else 0 end)"+ /* learning */
      " from revlog, cards where revlog.cid = cards.id and revlog.id > " + dayStartCutoff +
      " group by cards.did";
  Timber.d("AdvancedStatistics.TodayStats query: %s", query);
  try {
    cur = db.query(query, null);
    while(cur.moveToNext()) {
      nLearnedPerDeckId.put(cur.getLong(0), cur.getInt(1));
    }
  } finally {
    if (cur != null && !cur.isClosed()) {
      cur.close();
    }
  }
}