androidx.room.RoomDatabase Java Examples

/**
 * Performs the SQLiteQuery on the given database.
 * <p>
 * This util method encapsulates copying the cursor if the {@code maybeCopy} parameter is
 * {@code true} and either the api level is below a certain threshold or the full result of the
 * query does not fit in a single window.
 *
 * @param db          The database to perform the query on.
 * @param sqLiteQuery The query to perform.
 * @param maybeCopy   True if the result cursor should maybe be copied, false otherwise.
 * @param signal      The cancellation signal to be attached to the query.
 * @return Result of the query.
 */
@NonNull
public static Cursor query(@NonNull RoomDatabase db, @NonNull SupportSQLiteQuery sqLiteQuery,
        boolean maybeCopy, @Nullable CancellationSignal signal) {
    final Cursor cursor = db.query(sqLiteQuery, signal);
    if (maybeCopy && cursor instanceof AbstractWindowedCursor) {
        AbstractWindowedCursor windowedCursor = (AbstractWindowedCursor) cursor;
        int rowsInCursor = windowedCursor.getCount(); // Should fill the window.
        int rowsInWindow;
        if (windowedCursor.hasWindow()) {
            rowsInWindow = windowedCursor.getWindow().getNumRows();
        } else {
            rowsInWindow = rowsInCursor;
        }
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M || rowsInWindow < rowsInCursor) {
            return CursorUtil.copyAndClose(windowedCursor);
        }
    }

    return cursor;
}
 

static StuffDatabase create(Context ctxt, boolean memoryOnly, boolean truncate) {
  RoomDatabase.Builder<StuffDatabase> b;

  if (memoryOnly) {
    b=Room.inMemoryDatabaseBuilder(ctxt.getApplicationContext(),
      StuffDatabase.class);
  }
  else {
    b=Room.databaseBuilder(ctxt.getApplicationContext(), StuffDatabase.class,
      DB_NAME);
  }

  if (truncate) {
    b.setJournalMode(JournalMode.TRUNCATE);
  }

  b.openHelperFactory(SafeHelperFactory.fromUser(new SpannableStringBuilder("sekrit")));

  return(b.build());
}
 

public void reopenDatabase(boolean truncate) throws SQLiteDatabaseCorruptException {
    if (appDB != null) {
        appDB.close();
    }

    appDB = Room.databaseBuilder(context, AppDatabase.class, DATABASE_NAME)
            .allowMainThreadQueries()
            .setJournalMode(truncate == true ? RoomDatabase.JournalMode.TRUNCATE : RoomDatabase.JournalMode.AUTOMATIC) // in truncate mode no sql cache files (-shm, -wal) are generated
            .addCallback(new RoomDatabase.Callback() {
                @Override
                public void onOpen(SupportSQLiteDatabase db) {
                    super.onOpen(db);
                    db.setForeignKeyConstraintsEnabled(true);
                }
            })
            .addMigrations(AppDatabase.MIGRATION_1_2, AppDatabase.MIGRATION_2_3, AppDatabase.MIGRATION_3_4, AppDatabase.MIGRATION_4_5)
            .build();
    measurementDAO = appDB.measurementDAO();
    userDAO = appDB.userDAO();
}
 

protected LimitOffsetDataSource(RoomDatabase db, RoomSQLiteQuery query,
        boolean inTransaction, String... tables) {
    mDb = db;
    mSourceQuery = query;
    mInTransaction = inTransaction;
    mCountQuery = "SELECT COUNT(*) FROM ( " + mSourceQuery.getSql() + " )";
    mLimitOffsetQuery = "SELECT * FROM ( " + mSourceQuery.getSql() + " ) LIMIT ? OFFSET ?";
    mObserver = new InvalidationTracker.Observer(tables) {
        @Override
        public void onInvalidated(@NonNull Set<String> tables) {
            invalidate();
        }
    };
    db.getInvalidationTracker().addWeakObserver(mObserver);
}
 

private static RoomDatabase.Builder<DB> getBuilder(Context context) {
    try {
        ReLinker.log(new ReLinker.Logger() {
            @Override
            public void log(String message) {
                Log.i("Relinker: " + message);
            }
        }).loadLibrary(context, "sqlite3x");
    } catch (Throwable ex) {
        Log.e(ex);
    }

    SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
    int threads = prefs.getInt("query_threads", 4); // AndroidX default thread count: 4
    Log.i("Query threads=" + threads);
    ExecutorService executor = Helper.getBackgroundExecutor(threads, "query");

    return Room
            .databaseBuilder(context, DB.class, DB_NAME)
            .openHelperFactory(new RequerySQLiteOpenHelperFactory())
            .setQueryExecutor(executor)
            .setJournalMode(JournalMode.WRITE_AHEAD_LOGGING) // using the latest sqlite
            .addCallback(new Callback() {
                @Override
                public void onOpen(@NonNull SupportSQLiteDatabase db) {
                    Log.i("Database version=" + db.getVersion());

                    createTriggers(db);
                }
            });
}
 

protected LimitOffsetDataSource(RoomDatabase db, SupportSQLiteQuery query,
        boolean inTransaction, String... tables) {
    this(db, RoomSQLiteQuery.copyFrom(query), inTransaction, tables);
}
 

/**
 * Performs the SQLiteQuery on the given database.
 * <p>
 * This util method encapsulates copying the cursor if the {@code maybeCopy} parameter is
 * {@code true} and either the api level is below a certain threshold or the full result of the
 * query does not fit in a single window.
 *
 * @param db          The database to perform the query on.
 * @param sqLiteQuery The query to perform.
 * @param maybeCopy   True if the result cursor should maybe be copied, false otherwise.
 * @return Result of the query.
 *
 * @deprecated This is only used in the generated code and shouldn't be called directly.
 */
@Deprecated
@NonNull
public static Cursor query(RoomDatabase db, SupportSQLiteQuery sqLiteQuery, boolean maybeCopy) {
    return query(db, sqLiteQuery, maybeCopy, null);
}