Usage Docs

DBFlow is a Kotlin SQLite library for Android that makes it ridiculously easy to interact and use databases. Built with Annotation Processing, code use within a DB is fast, efficient, and type-safe. It removes the tedious (and tough-to-maintain) database interaction code, while providing a very SQLite-like query syntax.
Creating a database is as easy as a few lines of code:
@Database(version = 1)
abstract class AppDatabase: DBFlowDatabase
The @Database annotation generates a DatabaseDefinition which now references your SQLite Database on disk in the file named "AppDatabase.db". You can reference it in code as:
val db = database<AppDatabase>();
// or
database<AppDatabase> { db ->
To ensure generated code in DBFlow is found by the library, initialize the library in your Application class:
class MyApp : Application {
override fun onCreate() {
By default, DBFlow generates the GeneratedDatabaseHolder class, which is instantiated once by reflection, only once in memory.
Creating a table is also very simple:
@Table(database = AppDatabase::class, name = "User2")
class User(@PrimaryKey var id: Int = 0,
var firstName: String? = null,
var lastName: String? = null,
var email: String? = null)
Then to create, read, update, and delete the model:
// always utilize DB transactions when possible.
databaseForTable<User>().executeTransaction { db ->
val user = User(id = UUID.randomUUID(),
name = "Andrew Grosner",
age = 27)
user.name = "Not Andrew Grosner";
// find adult users synchronously
val users = (select from User::class
where (User_Table.age greaterThan 18))
// or asynchronous retrieval (preferred)
(select from User::class where User_Table.age.greaterThan(18))
.async(database<AppDatabase>()) { queryList(it) }
success = { transaction, result ->
// use result here
error = { transaction, error ->
// handle any errors
// use coroutines! or RX3 or LiveData
async {
val result = (delete<SimpleModel>() where SimpleModel_Table.name.eq("5"))
.awaitTransact(db) { executeUpdateDelete(database) }