Using Room Database

dependencies {
    implementation "androidx.room:room-runtime:2.5.0"
    implementation "androidx.room:room-ktx:2.5.0"
    kapt "androidx.room:room-compiler:2.5.0"
}

@Entity(tableName = "users")
data class User(
    @PrimaryKey(autoGenerate = true)
    val id: Int,
    
    @ColumnInfo(name = "full_name")
    val name: String,
    
    @ColumnInfo(name = "email_address")
    val email: String
)

@Entity(
    tableName = "user_preferences",
    primaryKeys = ["userId", "preferenceKey"]
)
data class UserPreference(
    val userId: Int,
    val preferenceKey: String,
    
    @ColumnInfo(name = "preference_value")
    val value: String
)

@Dao
interface UserDao {
    @Insert
    suspend fun insertUser(user: User)

    @Update
    suspend fun updateUser(user: User)

    @Delete
    suspend fun deleteUser(user: User)

    @Query("SELECT * FROM users")
    suspend fun getAllUsers(): List<User>

    @Query("SELECT * FROM users WHERE id = :userId")
    suspend fun getUserById(userId: Int): User?
}

@Dao
interface UserDao {
    @Query("SELECT * FROM users")
    fun getAllUsers(): LiveData<List<User>>

    @Query("SELECT * FROM users WHERE name = :name")
    fun getUsersByName(name: String): LiveData<List<User>>
}

@Database(
    entities = [User::class],
    version = 1
)
abstract class AppDatabase : RoomDatabase() {
    abstract fun userDao(): UserDao
}

class MyApplication : Application() {
    val database by lazy {
        Room.databaseBuilder(
            applicationContext,
            AppDatabase::class.java,
            "app_database"
        ).build()
    }
}

@TypeConverter
fun dateToTimestamp(date: Date?): Long? {
    return date?.time
}

@TypeConverter
fun timestampToDate(timestamp: Long?): Date? {
    return timestamp?.let { Date(it) }
}

@TypeConverter
fun listToString(list: List<String&gt?): String? {
    return list?.joinToString(",")
}

@TypeConverter
fun stringToList(string: String?): List<String>? {
    return string?.split(",")
}

import androidx.room.*

@Entity(tableName = "users")
data class User(
    @PrimaryKey val userId: Int,
    val name: String
)

@Entity(tableName = "posts", foreignKeys = [
    ForeignKey(
        entity = User::class,
        parentColumns = ["userId"],
        childColumns = ["authorId"],
        onDelete = ForeignKey.CASCADE
    )
])
data class Post(
    @PrimaryKey val postId: Int,
    val title: String,
    val content: String,
    val authorId: Int
)

import androidx.room.*

// Junction table for many-to-many relationship
@Entity(
    primaryKeys = ["userId", "postId"],
    foreignKeys = [
        ForeignKey(
            entity = User::class,
            parentColumns = ["userId"],
            childColumns = ["userId"]
        ),
        ForeignKey(
            entity = Post::class,
            parentColumns = ["postId"],
            childColumns = ["postId"]
        )
    ]
)
data class UserPost(
    val userId: Int,
    val postId: Int
)

// User entity
@Entity(tableName = "users")
data class User(
    @PrimaryKey val userId: Int,
    val name: String
)

// Post entity
@Entity(tableName = "posts")
data class Post(
    @PrimaryKey val postId: Int,
    val title: String,
    val content: String
)

class UserDao {
    @Query("SELECT * FROM users")
    fun getAllUsers(): LiveData<List<User>>
}

class UserViewModel(private val userDao: UserDao) : ViewModel() {
    val allUsers: LiveData<List<User>> = userDao.getAllUsers()
}

class UserDao {
    @Query("SELECT * FROM users")
    suspend fun getAllUsers(): Flow<List<User>>
}

class UserViewModel(private val userDao: UserDao) : ViewModel() {
    fun getAllUsers(): Flow<List<User>> = userDao.getAllUsers()
}

val MIGRATION_1_2 = object : Migration(1, 2) {
    override fun migrate(database: SupportSQLiteDatabase) {
        database.execSQL("ALTER TABLE users ADD COLUMN last_login TEXT")
    }
}

val db = Room.databaseBuilder(context, MyDatabase::class.java, "mydb").build()

db.runInTransaction {
    // Insert data
    val user = User(1, "John Doe")
    userDao.insert(user)

    // Update data
    val updatedUser = User(1, "John Smith")
    userDao.update(updatedUser)

    // Delete data
    userDao.delete(user)
}

import androidx.room.Room
import androidx.test.ext.junit.runners.AndroidJUnit4
import androidx.test.platform.app.InstrumentationRegistry
import org.junit.After
import org.junit.Before
import org.junit.Test
import org.junit.runner.RunWith

@RunWith(AndroidJUnit4::class)
class RoomDatabaseTest {

    private lateinit var db: MyDatabase
    private lateinit var userDao: UserDao

    @Before
    fun createDb() {
        val context = InstrumentationRegistry.getInstrumentation().targetContext
        db = Room.inMemoryDatabaseBuilder(context, MyDatabase::class.java).build()
        userDao = db.userDao()
    }

    @After
    fun closeDb() {
        db.close()
    }

    @Test
    fun insertAndRetrieveUser() {
        val user = User(1, "John Doe")
        userDao.insert(user)

        val retrievedUser = userDao.getUserById(1)
        assert(retrievedUser?.name == "John Doe")
    }
}

import androidx.room.*

@Entity
@Fts4
data class Article(
    @PrimaryKey
    val id: Int,
    val title: String,
    val content: String
)

@Dao
interface ArticleDao {
    @Query("SELECT * FROM articles WHERE articles MATCH :query")
    fun searchArticles(query: String): List<Article>
}

import androidx.paging.PagedList
import androidx.room.*

@Entity
data class User(
    @PrimaryKey val id: Int,
    val name: String,
    val email: String
)

@Dao
interface UserDao {
    @Query("SELECT * FROM user")
    fun getAllUsers(): LiveData<PagedList<User>>
}

@Database(
    entities = [User::class],
    version = 1
)
abstract class AppDatabase : RoomDatabase() {
    abstract fun userDao(): UserDao
}

import androidx.paging.PagingSource
import androidx.room.*

class UserPagingSource(
    private val userDao: UserDao
) : PagingSource<Int, User>() {
    override suspend fun load(params: LoadParams<Int>): LoadResult<Int, User> {
        val position = params.key ?: 0
        val pageSize = params.loadSize
        val users = userDao.getUsersPage(position, pageSize)
        return LoadResult.Page(
            data = users,
            prevKey = if (position == 0) null else position - pageSize,
            nextKey = if (users.isEmpty()) null else position + pageSize
        )
    }

    override fun getRefreshKey(state: PagingState<Int, User>): Int? {
        return state.anchorPosition?.minus(state.config.pageSize / 2)
    }
}

import androidx.paging.PagedListAdapter
import androidx.recyclerview.widget.DiffUtil

class UserAdapter : PagedListAdapter<User, UserViewHolder>(
    object : DiffUtil.ItemCallback<User>() {
        override fun areItemsTheSame(oldItem: User, newItem: User): Boolean {
            return oldItem.id == newItem.id
        }

        override fun areContentsTheSame(oldItem: User, newItem: User): Boolean {
            return oldItem == newItem
        }
    }
) {
    override fun onBindViewHolder(holder: UserViewHolder, position: Int) {
        holder.bind(getItem(position)!!)
    }

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): UserViewHolder {
        val view = LayoutInflater.from(parent.context)
            .inflate(R.layout.user_item, parent, false)
        return UserViewHolder(view)
    }
}