Android Room 持久库: Upsert

Android 的 Room 持久性库优雅地包含了用于对象或集合的@Insert 和@Update 注释。但是，我有一个用例(包含模型的推送通知)需要 UPSERT，因为数据可能存在于数据库中，也可能不存在。

Sqlite 本身没有起伏，在这个 有个问题中描述了变通方法。考虑到那里的解决方案，如何将它们应用到 Room？

更具体地说，如何在 Room 中实现插入或更新而不会破坏任何外键约束？使用插入和 onPulse = REPLACE 将导致调用该行的任何外键的 onDelete。在我的例子中，onDelete 会导致级联，重新插入一行将导致删除其他表中具有外键的行。这不是预期的行为。

71729 次浏览
小开
最佳答案

编辑:

从版本 2.50-alpha03开始，Room 现在支持 @Upsert注释。 在 “现在在 Android 中”示例应用程序的 撤回请求中可以看到它的使用示例。

老答案:

我找不到一个可以插入或更新而不会对外键造成不必要更改的 SQLite 查询，所以我选择先插入，忽略发生冲突的情况，然后立即更新，同样忽略冲突。

插入和更新方法受到保护，因此外部类只能查看和使用 upsert 方法。请记住，如果任何 MyEntity POJOS 都有 null 字段，那么这并不是真正的颠覆，它们将覆盖数据库中当前可能存在的内容。这不是对我的警告，但它可能是对你的申请。

@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);
}
小开

为了更好地实现这一目标，我建议两种选择:

用 IGNORE作为 OnConflictStrategy检查 insert操作的返回值(如果返回值等于 -1，则表示没有插入 row) :

@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);
}
}

处理 insert操作中的异常，将 FAIL作为 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);
}
}
小开

只是一个更新如何做到这一点与 Kotlin 保留数据的模型(也许使用它在一个计数器的例子) :

//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)
}
}
}

还可以使用 datase.openHelper.writableDatabase.ExecSQL (“ SQL STATEMENT”)对更复杂的事务使用@Transaction 和数据库构造函数变量

小开

我能想到的另一种方法是通过查询获取 DAO 实体，然后执行所需的任何更新。 与这个线程中的其他解决方案相比，由于必须检索完整的实体，因此在运行时方面这可能效率较低，但是在允许的操作方面(比如要更新哪些字段/变量)允许更大的灵活性。

例如:

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

也许你可以这样做你的基刀。

使用@Transaction 保护 upsert 操作, 并尝试仅在插入失败时更新。

@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);
}
}
}
小开

这种说法应该是可行的:

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

如果该表有多个列，则可以使用

@Insert(onConflict = OnConflictStrategy.REPLACE)

替换行。

参考资料 -点击查看 Android Room Codelab 的小贴士

小开

这是 Kotlin 的规矩:

@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)
}
}
小开

如果您有遗留代码: Java 和 BaseDao as Interface中的一些实体(在这些实体中您不能添加函数体) ，或者对于 Java 子代而言，您太懒于用 extends替换所有 implements。

注意: 它只在 Kotlin 代码中有效，我相信你在 Kotlin 编写了新的代码，对吗? :)

最后，一个懒惰的解决方案是添加两个 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)
}
}
小开

我发现了一篇关于它的有趣的文章。

这是“相同的”作为张贴在 https://stackoverflow.com/a/50736568/4744263。但是，如果你想要一个惯用的、干净的 Kotlin 版本，那么你可以这样做:

    @Transaction
open fun insertOrUpdate(objList: List<T>) = insert(objList)
.withIndex()
.filter { it.value == -1L }
.forEach { update(objList[it.index]) }


@Insert(onConflict = OnConflictStrategy.IGNORE)
abstract fun insert(obj: List<T>): List<Long>


@Update
abstract fun update(obj: T)
小开

或者像@yeonseok 中建议的那样，手动在循环中使用 UPSERT。搜索引擎优化后，我们可以使用由 Sqlite v.3.24.0提供的 UPSERT特性在 Android Room。

现在，Android 11和 Android 12分别支持这个特性，默认的 Sqlite 版本是3.28.0和3.32.2。如果你需要在 Android 11之前的版本中使用它，你可以将默认的 Sqlite 项目替换为定制的 Sqlite 项目，比如这个 https://github.com/requery/sqlite-android(或者你自己构建的) ，以便拥有最新的 Sqlite 版本中提供的这些特性和其他特性，但是在默认情况下不能在 Android Sqlite 中使用。

如果你的 Sqlite 版本是从3.24.0开始的，你可以在 Android Room 中使用 UPSERT，如下所示:

@Query("INSERT INTO Person (name, phone) VALUES (:name, :phone) ON CONFLICT (name) DO UPDATE SET phone=excluded.phone")
fun upsert(name: String, phone: String)
小开

下面是在 Room库中使用 真的UPSERT子句的一种方法。

这种方法的主要优点是 您可以更新不知道其 ID 的行。

  1. 在项目中设置 Android SQLite 支持库，以便在所有设备上使用现代 SQLite 特性:
  2. 从基道继承你的道。
  3. 可能需要添加 BasicEntity: abstract fun toMap(): Map<String, Any?>

在你的刀上使用 UPSERT:

@Transaction
private suspend fun upsert(entity: SomeEntity): Map<String, Any?> {
return upsert(
SomeEntity.TABLE_NAME,
entity.toMap(),
setOf(SomeEntity.SOME_UNIQUE_KEY),
setOf(SomeEntity.ID),
)
}

// An entity has been created. You will get ID.
val rawEntity = someDao.upsert(SomeEntity(0, "name", "key-1"))


// An entity has been updated. You will get ID too, despite you didn't know it before, just by unique constraint!
val rawEntity = someDao.upsert(SomeEntity(0, "new name", "key-1"))

基本刀具:

import android.database.Cursor
import androidx.room.*
import androidx.sqlite.db.SimpleSQLiteQuery
import androidx.sqlite.db.SupportSQLiteQuery


abstract class BasicDao(open val database: RoomDatabase) {
/**
* Upsert all fields of the entity except those specified in [onConflict] and [excludedColumns].
*
* Usually, you don't want to update PK, you can exclude it in [excludedColumns].
*
* [UPSERT](https://www.sqlite.org/lang_UPSERT.html) syntax supported since version 3.24.0 (2018-06-04).
* [RETURNING](https://www.sqlite.org/lang_returning.html) syntax supported since version 3.35.0 (2021-03-12).
*/
protected suspend fun upsert(
table: String,
entity: Map<String, Any?>,
onConflict: Set<String>,
excludedColumns: Set<String> = setOf(),
returning: Set<String> = setOf("*")
): Map<String, Any?> {
val updatableColumns = entity.keys
.filter { it !in onConflict && it !in excludedColumns }
.map { "`${it}`=excluded.`${it}`" }


// build sql
val comma = ", "
val placeholders = entity.map { "?" }.joinToString(comma)
val returnings = returning.joinToString(comma) { if (it == "*") it else "`${it}`" }
val sql = "INSERT INTO `${table}` VALUES (${placeholders})" +
" ON CONFLICT(${onConflict.joinToString(comma)}) DO UPDATE SET" +
" ${updatableColumns.joinToString(comma)}" +
" RETURNING $returnings"


val query: SupportSQLiteQuery = SimpleSQLiteQuery(sql, entity.values.toTypedArray())
val cursor: Cursor = database.openHelper.writableDatabase.query(query)


return getCursorResult(cursor).first()
}


protected fun getCursorResult(cursor: Cursor, isClose: Boolean = true): List<Map<String, Any?>> {
val result = mutableListOf<Map<String, Any?>>()
while (cursor.moveToNext()) {
result.add(cursor.columnNames.mapIndexed { index, columnName ->
val columnValue = if (cursor.isNull(index)) null else cursor.getString(index)
columnName to columnValue
}.toMap())
}


if (isClose) {
cursor.close()
}
return result
}
}

实体例子:

import androidx.room.ColumnInfo
import androidx.room.Entity
import androidx.room.Index
import androidx.room.PrimaryKey


@Entity(
tableName = SomeEntity.TABLE_NAME,
indices = [Index(value = [SomeEntity.SOME_UNIQUE_KEY], unique = true)]
)
data class SomeEntity(
@PrimaryKey(autoGenerate = true)
@ColumnInfo(name = ID)
val id: Long,


@ColumnInfo(name = NAME)
val name: String,


@ColumnInfo(name = SOME_UNIQUE_KEY)
val someUniqueKey: String,
) {
companion object {
const val TABLE_NAME = "some_table"
const val ID = "id"
const val NAME = "name"
const val SOME_UNIQUE_KEY = "some_unique_key"
}


fun toMap(): Map<String, Any?> {
return mapOf(
ID to if (id == 0L) null else id,
NAME to name,
SOME_UNIQUE_KEY to someUniqueKey
)
}
}
小开

@Upsert现在可在房间版本 2.5.0-beta01 看看释放记录


提交答案