Android Oda Kalıcı Kitaplığı: Yukarı

Android'in Oda kalıcılığı kitaplığı, nesneler veya koleksiyonlar için çalışan @Insert ve @Update ek açıklamalarını zarif bir şekilde içerir. Bununla birlikte, veriler veritabanında mevcut olabileceği veya bulunmayabileceği için bir UPSERT gerektirecek bir kullanım durumum (bir model içeren push bildirimleri) var.

Sqlite yerel olarak yükseltmeye sahip değildir ve geçici çözümler bu SO sorusunda açıklanmıştır . Buradaki çözümler göz önüne alındığında, bunları Room'a nasıl uygularsınız?

Daha spesifik olmak gerekirse, herhangi bir yabancı anahtar kısıtlamasını bozmayacak bir ekleme veya güncellemeyi Room'da nasıl uygulayabilirim? OnConflict = REPLACE ile insert kullanmak, o satıra yönelik herhangi bir yabancı anahtar için onDelete'in çağrılmasına neden olacaktır. Benim durumumda onDelete bir basamaklamaya neden olur ve bir satırı yeniden eklemek, yabancı anahtarın bulunduğu diğer tablolardaki satırların silinmesine neden olur. Bu amaçlanan davranış DEĞİLDİR.

Belki de Basedao'nuzu böyle yapabilirsiniz.

yükseltme işlemini @Transaction ile güvenli hale getirin ve yalnızca ekleme başarısız olursa güncellemeye çalışın.

@Dao
public abstract class BaseDao<T> {
    /**
    * Insert an object in the database.
    *
     * @param obj the object to be inserted.
     * @return The SQLite row id
     */
    @Insert(onConflict = OnConflictStrategy.IGNORE)
    public abstract long insert(T obj);

    /**
     * Insert an array of objects in the database.
     *
     * @param obj the objects to be inserted.
     * @return The SQLite row ids   
     */
    @Insert(onConflict = OnConflictStrategy.IGNORE)
    public abstract List<Long> insert(List<T> obj);

    /**
     * Update an object from the database.
     *
     * @param obj the object to be updated
     */
    @Update
    public abstract void update(T obj);

    /**
     * Update an array of objects from the database.
     *
     * @param obj the object to be updated
     */
    @Update
    public abstract void update(List<T> obj);

    /**
     * Delete an object from the database
     *
     * @param obj the object to be deleted
     */
    @Delete
    public abstract void delete(T obj);

    @Transaction
    public void upsert(T obj) {
        long id = insert(obj);
        if (id == -1) {
            update(obj);
        }
    }

    @Transaction
    public void upsert(List<T> objList) {
        List<Long> insertResult = insert(objList);
        List<T> updateList = new ArrayList<>();

        for (int i = 0; i < insertResult.size(); i++) {
            if (insertResult.get(i) == -1) {
                updateList.add(objList.get(i));
            }
        }

        if (!updateList.isEmpty()) {
            update(updateList);
        }
    }
}

Bunu yapmanın daha zarif bir yolu için iki seçenek öneririm:

A insertile işlemden dönüş değeri kontrol IGNOREediliyor OnConflictStrategy(-1'e eşitse satır eklenmemiş demektir):

@Insert(onConflict = OnConflictStrategy.IGNORE)
long insert(Entity entity);

@Update(onConflict = OnConflictStrategy.IGNORE)
void update(Entity entity);

@Transaction
public void upsert(Entity entity) {
    long id = insert(entity);
    if (id == -1) {
        update(entity);   
    }
}

Dan istisna Handling insertile operasyon FAILbir şekilde OnConflictStrategy:

@Insert(onConflict = OnConflictStrategy.FAIL)
void insert(Entity entity);

@Update(onConflict = OnConflictStrategy.FAIL)
void update(Entity entity);

@Transaction
public void upsert(Entity entity) {
    try {
        insert(entity);
    } catch (SQLiteConstraintException exception) {
        update(entity);
    }
}

Yabancı anahtarımda istenmeyen değişikliklere neden olmadan eklenecek veya güncellenecek bir SQLite sorgusu bulamadım, bu yüzden ilk önce eklemeyi seçtim, eğer meydana gelirse çakışmaları yok sayarak ve hemen ardından güncellemeyi yine çakışmaları yok sayarak.

Ekleme ve güncelleme yöntemleri korumalıdır, böylece harici sınıflar yalnızca yükseltme yöntemini görür ve kullanır. Bunun, MyEntity POJOS'larından herhangi birinin boş alanları varmış gibi gerçek bir yükseltme olmadığını, veritabanında şu anda olabilecek olanın üzerine yazacaklarını unutmayın. Bu benim için bir uyarı değil, ancak başvurunuz için olabilir.

@Insert(onConflict = OnConflictStrategy.IGNORE)
protected abstract void insert(List<MyEntity> entities);

@Update(onConflict = OnConflictStrategy.IGNORE)
protected abstract void update(List<MyEntity> entities);

@Transaction
public void upsert(List<MyEntity> entities) {
    insert(models);
    update(models);
}

Tabloda birden fazla sütun varsa, kullanabilirsiniz

@Insert(onConflict = OnConflictStrategy.REPLACE)

bir satırı değiştirmek için.

Referans - Android Room Codelab ipuçlarına git

Kotlin'deki kod budur:

@Insert(onConflict = OnConflictStrategy.IGNORE)
fun insert(entity: Entity): Long

@Update(onConflict = OnConflictStrategy.REPLACE)
fun update(entity: Entity)

@Transaction
fun upsert(entity: Entity) {
  val id = insert(entity)
   if (id == -1L) {
     update(entity)
  }
}

Modelin Kotlin tutma verileriyle bunun nasıl yapılacağına dair bir güncelleme (Belki örnek olarak bir sayaçta kullanabilirsiniz):

//Your Dao must be an abstract class instead of an interface (optional database constructor variable)
@Dao
abstract class ModelDao(val database: AppDatabase) {

@Insert(onConflict = OnConflictStrategy.FAIL)
abstract fun insertModel(model: Model)

//Do a custom update retaining previous data of the model 
//(I use constants for tables and column names)
 @Query("UPDATE $MODEL_TABLE SET $COUNT=$COUNT+1 WHERE $ID = :modelId")
 abstract fun updateModel(modelId: Long)

//Declare your upsert function open
open fun upsert(model: Model) {
    try {
       insertModel(model)
    }catch (exception: SQLiteConstraintException) {
        updateModel(model.id)
    }
}
}

Ayrıca, database.openHelper.writableDatabase.execSQL ("SQL STATEMENT") kullanarak daha karmaşık işlemler için @Transaction ve veritabanı yapıcı değişkenini de kullanabilirsiniz.

Aklıma gelen başka bir yaklaşım, varlığı DAO aracılığıyla sorguya almak ve ardından istenen güncellemeleri yapmaktır. Bu, tam varlığı almak zorunda olduğu için çalışma zamanı açısından bu iş parçacığındaki diğer çözümlere kıyasla daha az verimli olabilir, ancak hangi alanların / değişkenlerin güncelleneceği gibi izin verilen işlemler açısından çok daha fazla esneklik sağlar.

Örneğin :

private void upsert(EntityA entityA) {
   EntityA existingEntityA = getEntityA("query1","query2");
   if (existingEntityA == null) {
      insert(entityA);
   } else {
      entityA.setParam(existingEntityA.getParam());
      update(entityA);
   }
}

Bu tür bir ifade ile mümkün olmalı:

INSERT INTO table_name (a, b) VALUES (1, 2) ON CONFLICT UPDATE SET a = 1, b = 2

Eski kodunuz varsa: Java'daki bazı varlıklar ve BaseDao as Interface(bir işlev gövdesi ekleyemediğiniz yerlerde) veya hepsini Java çocukları implementsile değiştirmek için çok tembelsiniz extends.

Not: Yalnızca Kotlin kodunda çalışır. Kotlin'de yeni kod yazdığına eminim, değil mi? :)

Son olarak tembel bir çözüm, iki tane eklemektir Kotlin Extension functions:

fun <T> BaseDao<T>.upsert(entityItem: T) {
    if (insert(entityItem) == -1L) {
        update(entityItem)
    }
}

fun <T> BaseDao<T>.upsert(entityItems: List<T>) {
    val insertResults = insert(entityItems)
    val itemsToUpdate = arrayListOf<T>()
    insertResults.forEachIndexed { index, result ->
        if (result == -1L) {
            itemsToUpdate.add(entityItems[index])
        }
    }
    if (itemsToUpdate.isNotEmpty()) {
        update(itemsToUpdate)
    }
}