IssueTracker

Component used: support database classes
Version used: 1.0.0-beta1
Devices/Android versions reproduced on: n/a

https://issuetracker.google.com/issues/38481640#comment15

This work got lost when that issue was marked as fixed.

We really need SupportSQLiteQuery to expose a getArgCount() (or the equivalent). In principle, we need the arguments themselves to be exposed, but so far we have been getting away without those.

Quoting myself from the above comment:

"The docs for rawQueryWithFactory() on SQLiteDatabase say the following for the selectionArgs parameter: "You may include ?s in where clause in the query, which will be replaced by the values from selectionArgs. The values will be bound as Strings."

"The FrameworkSQLiteDatabase implementation passes an empty String[] to rawQueryWithFactory()... then assumes that it can actually bind selection arguments later, despite saying (via the empty String[]) that there aren't any selection arguments.

"Perhaps that works with the native SQLiteDatabase, but it would appear that SQLCipher for Android assumes that the code calling rawQueryWithFactory() isn't lying about the selection arguments. Hence, we need those arguments (or perhaps just the count) before calling rawQueryWithFactory() on SQLCipher's SQLiteDatabase, but mBindArgs is private in SimpleSQLiteQuery, and in some cases, we are not the ones creating the SimpleSQLiteQuery instance (so we can't fork SimpleSQLiteQuery and provide our own implementation)."

So, for example, lacking a getArgCount(), we have to use reflection to try to get that value from some stock SupportSQLiteQuery implementations:

  @Override
  public Cursor query(final SupportSQLiteQuery supportQuery,
                      CancellationSignal signal) {
    int count=0;

    try {
      if (supportQuery instanceof RoomSQLiteQuery) {
        Field argCount = RoomSQLiteQuery.class.getDeclaredField("mArgCount");
        argCount.setAccessible(true);
        count = argCount.getInt(supportQuery);
      }
      else if (supportQuery instanceof SimpleSQLiteQuery) {
        Field bindArgs = SimpleSQLiteQuery.class.getDeclaredField("mBindArgs");
        bindArgs.setAccessible(true);
        Object[] bindArgsValue = (Object[]) bindArgs.get(supportQuery);
        count = bindArgsValue!=null?bindArgsValue.length:0;
      }
      else {
        throw new IllegalArgumentException("Unexpected SupportSQLiteQuery type: "
          +supportQuery.getClass().getCanonicalName());
      }
    }
    catch (Exception e) {
      throw new IllegalStateException("Um, ick", e);
    }

    String[] fakeArgs=new String[count];

    for (int i=0;i<count;i++) {
      fakeArgs[i]="";
    }

    return(safeDb.rawQueryWithFactory(
      new net.sqlcipher.database.SQLiteDatabase.CursorFactory() {
        @Override
        public net.sqlcipher.Cursor newCursor(
          net.sqlcipher.database.SQLiteDatabase db,
          SQLiteCursorDriver masterQuery, String editTable,
          SQLiteQuery query) {
          supportQuery.bindTo(new Program(query));
          return new SQLiteCursor(db, masterQuery, editTable, query);
        }
      }, supportQuery.getSql(), fakeArgs, null));
  }

Adding getArgCount() would eliminate the reflection. We still wind up lying to SQLCipher for Android (and possibly other SQLite implementations) about the arguments, so it'll still be ugly, just less ugly.