Biblioteca Android Room Persistence: Upsert

A biblioteca de persistência Room do Android graciosamente inclui as anotações @Insert e @Update que funcionam para objetos ou coleções. No entanto, tenho um caso de uso (notificações push contendo um modelo) que exigiria um UPSERT, pois os dados podem ou não existir no banco de dados.

O Sqlite não tem upsert nativamente e as soluções alternativas são descritas nesta pergunta do SO . Dadas as soluções lá, como aplicá-las à Room?

Para ser mais específico, como posso implementar uma inserção ou atualização na Room que não quebraria nenhuma restrição de chave estrangeira? Usar insert com onConflict = REPLACE fará com que o onDelete de qualquer chave estrangeira para aquela linha seja chamada. No meu caso, onDelete causa uma cascata e a reinserção de uma linha fará com que as linhas em outras tabelas com a chave estrangeira sejam excluídas. Este NÃO é o comportamento pretendido.

Talvez você possa fazer seu BaseDao assim.

proteja a operação de upsert com @Transaction e tente atualizar apenas se a inserção falhar.

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

Para uma maneira mais elegante de fazer isso, sugiro duas opções:

Verificando o valor de retorno da insertoperação com IGNOREas a OnConflictStrategy(se for igual a -1, significa que a linha não foi inserida):

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

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

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

Lidando com exceção de insertoperação FAILcomo OnConflictStrategy:

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

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

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

Não consegui encontrar uma consulta SQLite que pudesse inserir ou atualizar sem causar alterações indesejadas em minha chave estrangeira, então, em vez disso, optei por inserir primeiro, ignorando os conflitos se eles ocorressem e atualizando imediatamente depois, novamente ignorando os conflitos.

Os métodos de inserção e atualização são protegidos para que as classes externas vejam e usem apenas o método upsert. Lembre-se de que este não é um verdadeiro upsert, pois se algum dos POJOS do MyEntity tiver campos nulos, eles substituirão o que pode estar atualmente no banco de dados. Esta não é uma advertência para mim, mas pode ser para sua aplicação.

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

Se a tabela tiver mais de uma coluna, você pode usar

@Insert(onConflict = OnConflictStrategy.REPLACE)

para substituir uma linha.

Referência - Vá para dicas Android Room Codelab

Este é o código em 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)
  }

}

Apenas uma atualização de como fazer isso com Kotlin retendo dados do modelo (talvez para usá-lo em um contador como no exemplo):

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

Você também pode usar @Transaction e variável de construtor de banco de dados para transações mais complexas usando database.openHelper.writableDatabase.execSQL ("SQL STATEMENT")

Outra abordagem que posso pensar é obter a entidade por meio do DAO por consulta e, em seguida, executar as atualizações desejadas. Isso pode ser menos eficiente em comparação com as outras soluções neste segmento em termos de tempo de execução por ter que recuperar a entidade completa, mas permite muito mais flexibilidade em termos de operações permitidas, como em quais campos / variáveis ​​atualizar.

Por exemplo :

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

Deve ser possível com este tipo de declaração:

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