Bibliothèque de persistance de salle Android: Upsert

La bibliothèque de persistance Room d'Android comprend gracieusement les annotations @Insert et @Update qui fonctionnent pour les objets ou les collections. J'ai cependant un cas d'utilisation (notifications push contenant un modèle) qui nécessiterait un UPSERT car les données peuvent ou non exister dans la base de données.

Sqlite n'a pas d'upsert nativement, et les solutions de contournement sont décrites dans cette question SO . Compte tenu des solutions, comment les appliquerait-on à Room?

Pour être plus précis, comment puis-je implémenter une insertion ou une mise à jour dans Room qui ne briserait aucune contrainte de clé étrangère? L'utilisation d'insert avec onConflict = REPLACE entraînera l'appel de onDelete pour toute clé étrangère de cette ligne. Dans mon cas, onDelete provoque une cascade, et la réinsertion d'une ligne entraînera la suppression de lignes dans d'autres tables avec la clé étrangère. Ce n'est PAS le comportement prévu.

Peut-être que vous pouvez faire votre BaseDao comme ça.

sécurisez l'opération upsert avec @Transaction et essayez de mettre à jour uniquement si l'insertion échoue.

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

Pour une manière plus élégante de le faire, je suggérerais deux options:

Vérification de la valeur de retour de l' insertopération avec IGNOREas a OnConflictStrategy(si elle est égale à -1, cela signifie que la ligne n'a pas été insérée):

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

Traitement de l'exception d' insertopération avec FAILcomme 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);
    }
}

Je n'ai pas pu trouver de requête SQLite qui s'insérerait ou se mettrait à jour sans provoquer de modifications indésirables de ma clé étrangère.J'ai donc choisi d'insérer d'abord, en ignorant les conflits s'ils se produisaient et en mettant à jour immédiatement après, en ignorant à nouveau les conflits.

Les méthodes d'insertion et de mise à jour sont protégées afin que les classes externes voient et utilisent uniquement la méthode upsert. Gardez à l'esprit que ce n'est pas un véritable upsert, car si l'un des POJOS MyEntity avait des champs nuls, ils écraseraient ce qui peut actuellement se trouver dans la base de données. Ce n'est pas une mise en garde pour moi, mais peut-être pour votre application.

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

Si la table comporte plus d'une colonne, vous pouvez utiliser

@Insert(onConflict = OnConflictStrategy.REPLACE)

pour remplacer une ligne.

Référence - Aller aux astuces Android Room Codelab

Voici le code de 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)
  }

}

Juste une mise à jour pour savoir comment faire cela avec Kotlin en conservant les données du modèle (peut-être pour l'utiliser dans un compteur comme dans l'exemple):

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

Vous pouvez également utiliser @Transaction et la variable de constructeur de base de données pour des transactions plus complexes en utilisant database.openHelper.writableDatabase.execSQL ("SQL STATEMENT")

Une autre approche à laquelle je peux penser est d'obtenir l'entité via DAO par requête, puis d'effectuer les mises à jour souhaitées. Cela peut être moins efficace par rapport aux autres solutions de ce thread en termes d'exécution en raison de la nécessité de récupérer l'entité complète, mais permet beaucoup plus de flexibilité en termes d'opérations autorisées telles que sur les champs / variables à mettre à jour.

Par exemple :

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

Devrait être possible avec ce type de déclaration:

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