एंड्रॉइड रूम पर्सिस्टेंस लाइब्रेरी: उप्र

Question 1

एंड्रॉइड के कमरे की दृढ़ता पुस्तकालय में विनम्रतापूर्वक @Insert और @Update एनोटेशन शामिल हैं जो ऑब्जेक्ट या संग्रह के लिए काम करते हैं। हालाँकि मेरे पास एक उपयोग का मामला है (एक मॉडल युक्त सूचनाएँ) जिसमें एक यूपीएसईआरटी की आवश्यकता होगी क्योंकि डेटा डेटाबेस में मौजूद हो सकता है या नहीं भी हो सकता है।

Sqlite में मूल रूप से मुखर नहीं है, और इस SO प्रश्न में वर्कअराउंड वर्णित हैं । वहाँ के समाधानों को देखते हुए, कोई उन्हें कमरे में कैसे लागू करेगा?

अधिक विशिष्ट होने के लिए, मैं कमरे में एक सम्मिलित या अद्यतन कैसे लागू कर सकता हूं जो किसी भी विदेशी कुंजी बाधाओं को नहीं तोड़ सकता है? OnConflict के साथ इन्सर्ट का उपयोग करना = REPLACE का कारण उस पंक्ति के लिए किसी भी विदेशी कुंजी के ऑनडेट को कहा जाएगा। मेरे मामले में onDelete एक झरना का कारण बनता है, और एक पंक्ति को फिर से स्थापित करने से विदेशी कुंजी के साथ अन्य तालिकाओं में पंक्तियों को हटा दिया जाएगा। यह अभीष्ट व्यवहार नहीं है।

Question 2

शायद आप अपने बेसडॉ को इस तरह से बना सकते हैं।

@ ऑपरेशन के साथ अपटर ऑपरेशन को सुरक्षित करें, और केवल तभी अपडेट करने का प्रयास करें जब सम्मिलन विफल हो।

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

Question 3

अधिक सुरुचिपूर्ण तरीके से करने के लिए कि मैं दो विकल्प सुझाऊंगा:

insertऑपरेशन से रिटर्न वैल्यू की जाँच के IGNOREरूप में OnConflictStrategy(यदि यह -1 के बराबर है तो इसका मतलब है कि पंक्ति सम्मिलित नहीं की गई है):

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

से अपवाद हैंडलिंग insertके साथ आपरेशन FAILएक के रूप में 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);
    }
}

Question 4

मुझे एक ऐसी SQLite क्वेरी नहीं मिली, जो मेरी विदेशी कुंजी में अवांछित परिवर्तन किए बिना सम्मिलित या अपडेट करेगी, इसलिए मैंने पहले डालने का विकल्प चुना, यदि वे हुए तो संघर्षों को अनदेखा करना, और तुरंत बाद अपडेट करना, फिर से विरोधों को अनदेखा करना।

सम्मिलित करने और अपडेट करने के तरीके सुरक्षित हैं, इसलिए बाहरी कक्षाएं केवल ऊपरी विधि को देखती हैं और उनका उपयोग करती हैं। ध्यान रखें कि यह एक सच्चा उभार नहीं है जैसे कि MyEntity POJOS में से किसी के पास अशक्त क्षेत्र हैं, वे डेटाबेस में वर्तमान में क्या हो सकता है को अधिलेखित कर देंगे। यह मेरे लिए एक चेतावनी नहीं है, लेकिन यह आपके आवेदन के लिए हो सकता है।

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

Question 5

यदि तालिका में एक से अधिक स्तंभ हैं, तो आप उपयोग कर सकते हैं

@Insert(onConflict = OnConflictStrategy.REPLACE)

एक पंक्ति को बदलने के लिए।

संदर्भ - युक्तियों पर जाएं Android कक्ष कोडेलैब

Question 6

यह कोटलिन में कोड है:

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

Question 7

कोटलिन मॉडल के डेटा को बनाए रखने के साथ ऐसा करने के लिए बस एक अद्यतन (उदाहरण के रूप में एक काउंटर में इसका उपयोग करने के लिए शायद):

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

आप डेटाबेस का उपयोग करके अधिक जटिल लेनदेन के लिए @ ट्रांसशिप और डेटाबेस कंस्ट्रक्टर वैरिएबल का उपयोग भी कर सकते हैं ।openHelper.writableDatabase.execSQL ("SQL STATEMENT")

Question 8

एक अन्य दृष्टिकोण जो मैं सोच सकता हूं कि इकाई को डीएओ द्वारा क्वेरी के माध्यम से प्राप्त करना है, और फिर कोई वांछित अपडेट करना है। पूर्ण इकाई को पुनः प्राप्त करने के कारण रनटाइम के संदर्भ में इस थ्रेड में अन्य समाधानों की तुलना में यह कम कुशल हो सकता है, लेकिन संचालन के संदर्भ में बहुत अधिक लचीलेपन की अनुमति देता है जैसे कि क्या फ़ील्ड / चर अद्यतन करने के लिए।

उदाहरण के लिए :

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

Question 9

इस प्रकार के कथन से संभव होना चाहिए:

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

Question 10

यदि आपके पास विरासत कोड है: जावा में कुछ इकाइयाँ और BaseDao as Interface(जहाँ आप एक कार्य निकाय नहीं जोड़ सकते हैं) या आप जावा-बच्चों के लिए सभी के implementsसाथ बदलने के लिए बहुत आलसी हैं extends।

नोट: यह केवल कोटलिन कोड में काम करता है। मुझे यकीन है कि आप कोटलिन में नया कोड लिख रहे हैं, मैं सही हूं? :)

अंत में एक आलसी समाधान दो जोड़ना है 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)
    }
}