Você está querendo utilizar um banco de dados que seja reativo, para poder fazer todo seu app dinâmico?

Um bom exemplo de banco de dados é o ROOM, ele é o SQLite nativo mas com uma camada de ORM, que facilita sua manipulação.

Para utilizarmos o ROOM, precisamos importar ele para a nossa aplicação.

implementation "androidx.room:room-runtime:2.2.1" 
implementation "androidx.room:room-ktx:2.2.1" 
kapt "androidx.room:room-compiler:2.2.1"

Com os imports realizados precisamos criar ao menos um objeto que representará uma das tabelas.

@Entity(
tableName = "classe1",
  indices = [ 
    Index("valor1"), 
    Index("id") 
  ]
) data class Classe1( 
  @PrimaryKey(autoGenerate = true)
  val id: Int, 
  val valor1: String, 
  var valor2: String 
)

Com o objeto criado para representar uma classe, agora é necessário criar uma Interface que vai ser conter os métodos de manipulação da tabela

@Dao
interface Classe1DAO {

    @Query("DELETE FROM classe1")
    suspend fun deleteAll()

    @Insert(onConflict = OnConflictStrategy.REPLACE)
    suspend fun save(parameters: List<Classe1>)

    @Query("SELECT * FROM classe1")
    fun selectAll(): Array<Classe1>
}

Com a classe de Dao pronta, agora temos tudo para criar o nosso banco de dados.

@Database(
    version = MyDatabase.DATABASE_VERSION,
    exportSchema = false,
    entities = [Classe1::class/*...outras classes...*/]
)
abstract class MyDatabase : RoomDatabase() {

    companion object {
        const val DATABASE_NAME = "meuBD"
        const val DATABASE_VERSION = 1
    }

    abstract fun classe1DAO(): Classe1DAO
    /** Colocar todos os DAOs aqui **/
}

Com a Classe do nosso banco de dados pronta, agora podemos iniciar ele. Para isso basta executarmos o código abaixo no método onCreate da classe Application.

Room.databaseBuilder(get(), MyDatabase::class.java, MyDatabase.DATABASE_NAME).build()

Desta forma temos o nosso banco de dados funcionando, mas somente com uma única tabela, então para adicionarmos mais tabelas precisamos criar uma outra classe de Entity e uma de Dao como fizemos anteriormente, subir uma versão do banco de dados e também criarmos um objeto de migration.

Um objeto de migration é similar ao mostrado abaixo.

val MIGRATION_1_2 = object : Migration(1, 2){
    override fun migrate(database: SupportSQLiteDatabase) {
        database.execSQL("CREATE TABLE IF NOT EXISTS `Classe2` 
                           (`id` INTEGER, 
                           ....,
                           PRIMARY KEY(`id`))"
                        )
    }
}

Com a Migração criada temos que adicionar ela no nosso banco de dados, como mostrado no códio abaixo.

Room.databaseBuilder(get(), EVEDatabase::class.java, EVEDatabase.DATABASE_NAME).addMigrations(MIGRATION_1_2).build()

Como é necessário colocar os SQLs nas migrations, e isso pode ser MUITO custoso se o objeto ter muitos campos. Para facilitar isso temos duas formas de conseguir esses SQLs.

A primeira forma é exportar os schemas do banco de dados para isso temos que adicionar a anotação “exportSchema = true” na classe do banco de dados

@Database(
    version = MyDatabase.DATABASE_VERSION,
    exportSchema = true,
    entities = [Classe1::class/*...outras classes...*/]
)
abstract class MyDatabase : RoomDatabase() {

    companion object {
        const val DATABASE_NAME = "meuBD"
        const val DATABASE_VERSION = 1
    }

    abstract fun classe1DAO(): Classe1DAO
    /** Colocar todos os DAOs aqui **/
}

e também adicionar o código abaixo no Build.gradle do app

kapt {
    arguments {
        arg("room.schemaLocation", "$projectDir/schemas".toString())
    }
}

assim que executar o projeto vai ser criada uma pasta que vai ter JSONs com o número da versão, e nesse JSON vai conter todos os SQLs, então basta copiar e colar dentro do migration.

E a segunda forma de encontrar os SQLs, basta pesquisar por um arquivo auto gerado com o nome “meuBDDatabase_Impl”, nessa classe também contém todos os SQLs para poder se copiados.