E/SQLiteQuery: exception: Row too big to fit into CursorWindow requiredPos=0, totalRows=1; query: SELECT * FROM vet_product ORDER BY id ASC
E/AndroidRuntime: FATAL EXCEPTION: arch_disk_io_0
    Process: com.dimon.vetdatabasemobile, PID: 26700
    java.lang.RuntimeException: Exception while computing database live data.
        at androidx.room.RoomTrackingLiveData$1.run(RoomTrackingLiveData.java:92)
        at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1167)
        at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:641)
        at java.lang.Thread.run(Thread.java:923)
     Caused by: android.database.sqlite.SQLiteBlobTooBigException: Row too big to fit into CursorWindow requiredPos=0, totalRows=1
        at android.database.sqlite.SQLiteConnection.nativeExecuteForCursorWindow(Native Method)
        at android.database.sqlite.SQLiteConnection.executeForCursorWindow(SQLiteConnection.java:1001)
        at android.database.sqlite.SQLiteSession.executeForCursorWindow(SQLiteSession.java:838)
        at android.database.sqlite.SQLiteQuery.fillWindow(SQLiteQuery.java:62)
        at android.database.sqlite.SQLiteCursor.fillWindow(SQLiteCursor.java:153)
        at android.database.sqlite.SQLiteCursor.getCount(SQLiteCursor.java:140)
        at com.dimon.vetdatabasemobile.db.dao_s.ProductDao_Impl$5.call(ProductDao_Impl.java:172)
        at com.dimon.vetdatabasemobile.db.dao_s.ProductDao_Impl$5.call(ProductDao_Impl.java:163)
        at androidx.room.RoomTrackingLiveData$1.run(RoomTrackingLiveData.java:90)
        at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1167) 
        at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:641) 
        at java.lang.Thread.run(Thread.java:923) 

@Parcelize
@Entity(tableName = "vet_product")
data class Product(
    @PrimaryKey(autoGenerate = true) val id: Int = 0,
    val productName: String,
    val productPrice: Double,
    val productImage: Bitmap
) : Parcelable
@Parcelize
@Entity(tableName = "cart")
data class CartModel(
    @PrimaryKey(autoGenerate = true) val id: Long = 0,
    val productName: String,
    val productPrice: Double
) : Parcelable

@Dao
interface ProductDao {
    @Insert(onConflict = OnConflictStrategy.IGNORE)
    fun insert(product: Product)
    @Delete
    fun delete(product: Product)
    @Update
    fun update(product: Product)
    @Query("DELETE FROM vet_product")
    fun deleteAll()
    @Query("SELECT * FROM vet_product ORDER BY id ASC")
    fun getAllProducts(): LiveData<List<Product>>
interface CartDao {
    @Insert(onConflict = OnConflictStrategy.IGNORE)
    fun insertToCart(cartModel: CartModel)
    @Query("DELETE FROM cart")
    fun deleteAllFromCart()
    @Query("SELECT * FROM cart ORDER BY id ASC")
    fun getCartModels(): LiveData<List<CartModel>>
}

class ProductRepository(private val productDao: ProductDao) {
    val getAllProduct: LiveData<List<Product>> = productDao.getAllProducts()
    fun addProduct(product: Product) {
        productDao.insert(product)
    fun updateProduct(product: Product) {
        productDao.update(product)
    fun deleteProduct(product: Product) {
        productDao.delete(product)
    fun deleteAllProducts() {
        productDao.deleteAll()
class CartRepository(private val cartDao: CartDao) {
    val getAllCartModels: LiveData<List<CartModel>> = cartDao.getCartModels()
    fun addToCart(cartModel: CartModel) {
        cartDao.insertToCart(cartModel)
    fun deleteAllFromCart() {
        cartDao.deleteAllFromCart()
}

class ProductViewModel(application: Application) : AndroidViewModel(application) {
    val getAllProducts: LiveData<List<Product>>
    private val repository: ProductRepository
    init {
        val productDao = VetDatabase.getInstance(application).productDao()
        repository = ProductRepository(productDao)
        getAllProducts = repository.getAllProduct
    fun addProduct(product: Product) {
        viewModelScope.launch(Dispatchers.IO) {
            repository.addProduct(product)
    fun updateProduct(product: Product) {
        viewModelScope.launch(Dispatchers.IO) {
            repository.updateProduct(product)
    fun deleteProduct(product: Product) {
        viewModelScope.launch(Dispatchers.IO) {
            repository.deleteProduct(product)
    fun deleteAllProducts() {
        viewModelScope.launch(Dispatchers.IO) {
            repository.deleteAllProducts()
class CartViewModel(application: Application) : AndroidViewModel(application) {
    val getCartModels: LiveData<List<CartModel>>
    private val repository: CartRepository
    init {
        val cartDao = VetDatabase.getInstance(application).cartDao()
        repository = CartRepository(cartDao)
        getCartModels = repository.getAllCartModels
    fun addToCart(cartModel: CartModel) {
        viewModelScope.launch(Dispatchers.IO) {
            repository.addToCart(cartModel)
    fun deleteAllFromCart() {
        viewModelScope.launch(Dispatchers.IO) {
            repository.deleteAllFromCart()
}

@Database(entities = [Product::class, CartModel::class], version = 5, exportSchema = false)
@TypeConverters(Converters::class)
abstract class VetDatabase : RoomDatabase() {
    abstract fun productDao(): ProductDao
    abstract fun cartDao(): CartDao
    companion object {
        @Volatile
        private var INSTANCE: VetDatabase? = null
        fun getInstance(context: Context): VetDatabase {
            val tempInstance = INSTANCE
            if (tempInstance != null) {
                return tempInstance
            synchronized(this) {
                val instance = Room.databaseBuilder(
                    context.applicationContext,
                    VetDatabase::class.java,
                    "vet_db"
                    .fallbackToDestructiveMigration()
                    .allowMainThreadQueries()
                    .build()
                INSTANCE = instance