How to use

databaseBuilder

method

in

androidx.room.Room

  public static DeadlineDatabase getDatabase(final Context context) {
    if (INSTANCE == null) {
      synchronized (DeadlineDatabase.class) {
        if (INSTANCE == null) {
          INSTANCE = Room.databaseBuilder(context.getApplicationContext(),
              DeadlineDatabase.class, "event_database.db")
              .build();
        }
      }
    }
    return INSTANCE;
  }
}

private CredentialsHelper(Context ctx) {
  mDb = Room.databaseBuilder(ctx.getApplicationContext(),
      AppDatabase.class, "HPV").build();
}

public RoomImpl(Context context, Converter converter) {
  this.db = Room.databaseBuilder(context, AppDatabase.class, DB_NAME).build();
  this.converter = converter;
}

  private static MoviesDatabase buildDatabase(final Context context) {
    return Room.databaseBuilder(
        context.getApplicationContext(),
        MoviesDatabase.class,
        DATABASE_NAME).build();
  }
}

public static synchronized UserDatabase getInstance(Context context) {
  if (instance == null) {
    instance = Room.databaseBuilder(context, UserDatabase.class, DB_NAME)
        .allowMainThreadQueries()//默认room不允许在主线程操作数据库，这里设置允许
        .build();
  }
  return instance;
}

public static AppDatabase getInstance(Context context) {
  AppDatabase res = INSTANCE;
  if (res == null) {
    synchronized (AppDatabase.class) {
      res = INSTANCE;
      if (res == null) {
        res = Room.databaseBuilder(context.getApplicationContext(), AppDatabase.class, "fosdem.sqlite")
            .addMigrations(MIGRATION_1_2)
            .setJournalMode(JournalMode.TRUNCATE)
            .build();
        res.sharedPreferences = context.getApplicationContext().getSharedPreferences(DB_PREFS_FILE, Context.MODE_PRIVATE);
        INSTANCE = res;
      }
    }
  }
  return res;
}

public static synchronized TcaDb getInstance(Context context) {
  if (instance == null) {
    instance = Room.databaseBuilder(context.getApplicationContext(), TcaDb.class, Const.DATABASE_NAME)
        .allowMainThreadQueries()
        .addMigrations(migrations)
        .build();
  }
  return instance;
}

public static StudentDatabase getInstance(Context context) {
  if (instance == null) {
    instance = Room.databaseBuilder(context, StudentDatabase.class, "st.db")
        .addCallback(new Callback() {
          @Override
          public void onCreate(@NonNull SupportSQLiteDatabase db) {
            super.onCreate(db);
            new IOExecutor(() -> {
              //插入一些模拟数据
              List<Student> list = new ArrayList<>();
              Student student;
              for (String d : data) {
                student = new Student(d);
                list.add(student);
              }
              getInstance(context).getStudentDao().insert(list);
            });
          }
        })
        .build();
  }
  return instance;
}

 static ImportingLessSafeDatabase gimme(Context ctxt) {
  return Room.databaseBuilder(ctxt, ImportingLessSafeDatabase.class, DB_NAME)
   .addMigrations(MIGRATION_1_2)
   .build();
 }
}

@Override
public void setUp(Context context, PerfTestRunner testRunner) {
  super.setUp(context, testRunner);
  boolean deleted = context.deleteDatabase(DB_NAME);
  if (deleted) {
    log("DB existed before start - deleted");
  }
  db = Room.databaseBuilder(context.getApplicationContext(), AppDatabase.class, DB_NAME)
      .build();
  dao = db.simpleEntityDao();
  daoIndexed = db.simpleEntityIndexedDao();
  if (!versionLoggedOnce) {
    Cursor cursor = db.query("select sqlite_version() AS sqlite_version", null);
    if (cursor != null) {
      try {
        if (cursor.moveToFirst()) {
          log("SQLite version " + cursor.getString(0));
        }
      } finally {
        cursor.close();
      }
    }
    versionLoggedOnce = true;
  }
}

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

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

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

  return(b.build());
 }
}

 static ImportingSafeDatabase gimme(Context ctxt) {
  return Room.databaseBuilder(ctxt, ImportingSafeDatabase.class, DB_NAME)
   .openHelperFactory(new SafeHelperFactory(PASSPHRASE.toCharArray()))
   .addMigrations(MIGRATION_1_2)
   .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)
      .build();
  measurementDAO = appDB.measurementDAO();
  userDAO = appDB.userDAO();
}