एंड्रॉइड रूम डेटाबेस: एक एंटिटी में Arraylist कैसे संभालें?

Question 1

मैंने अभी ऑफ़लाइन डेटा सेविंग के लिए कमरा लागू किया है। लेकिन एक इकाई वर्ग में, मुझे निम्नलिखित त्रुटि मिल रही है:

Error:(27, 30) error: Cannot figure out how to save this field into database. You can consider adding a type converter for it.

और कक्षा निम्नलिखित है:

@Entity(tableName = "firstPageData")
public class MainActivityData {

    @PrimaryKey
    private String userId;

    @ColumnInfo(name = "item1_id")
    private String itemOneId;

    @ColumnInfo(name = "item2_id")
    private String itemTwoId;

    // THIS IS CAUSING THE ERROR... BASICALLY IT ISN'T READING ARRAYS
    @ColumnInfo(name = "mylist_array")
    private ArrayList<MyListItems> myListItems;

    public String getUserId() {
        return userId;
    }

    public void setUserId(String userId) {
        this.userId = userId;
    }

    public ArrayList<MyListItems> getMyListItems() {
        return myListItems;
    }

    public void setCheckListItems(ArrayList<MyListItems> myListItems) {
        this.myListItems = myListItems;
    }

}

इसलिए मूल रूप से मैं ArrayList को डेटाबेस में सहेजना चाहता हूं, लेकिन मैं इसके लिए प्रासंगिक कुछ भी नहीं पा रहा था। क्या आप मुझे निर्देशित कर सकते हैं कि कमरे का उपयोग करके एक ऐरे को कैसे बचाया जाए?

नोट: MyListItems पूजो वर्ग में 2 स्ट्रिंग्स शामिल हैं (अब के रूप में)

अग्रिम में धन्यवाद।

Question 2

विकल्प # 1: MyListItemsएक है @Entity, जैसा MainActivityDataहै। वापस MyListItemsस्थापित करना होगा । इस मामले में, हालांकि, जैसा कि कक्ष में नहीं हो सकता है , संस्थाएं अन्य संस्थाओं को संदर्भित नहीं करती हैं। एक दृश्य मॉडल या इसी तरह का POJO निर्माण हालांकि और उससे जुड़ा हो सकता है ।@ForeignKeyMainActivityDataMainActivityDataprivate ArrayList<MyListItems> myListItemsMainActivityDataArrayList<MyListItems>

विकल्प # 2: कुछ बुनियादी प्रकार से (जैसे, ए , जैसे कि जेएसएन को भंडारण प्रारूप के रूप में उपयोग करके) में @TypeConverterबदलने के ArrayList<MyListItems>लिए तरीकों की एक जोड़ी स्थापित करें String। अब, सीधे MainActivityDataकर सकते हैं ArrayList<MyListItems>। हालाँकि, इसके लिए कोई अलग तालिका नहीं होगी MyListItems, और इसलिए आप MyListItemsबहुत अच्छी तरह से क्वेरी नहीं कर सकते ।

Question 3

टाइप कन्वर्टर इसके लिए विशेष रूप से बनाए जाते हैं। आपके मामले में, आप DB में डेटा स्टोर करने के लिए नीचे दिए गए कोड स्निपेट का उपयोग कर सकते हैं।

public class Converters {
    @TypeConverter
    public static ArrayList<String> fromString(String value) {
        Type listType = new TypeToken<ArrayList<String>>() {}.getType();
        return new Gson().fromJson(value, listType);
    }

    @TypeConverter
    public static String fromArrayList(ArrayList<String> list) {
        Gson gson = new Gson();
        String json = gson.toJson(list);
        return json;
    }
}

और इस कक्षा का उल्लेख अपने कक्ष डीबी में इस तरह से करें

@Database (entities = {MainActivityData.class},version = 1)
@TypeConverters({Converters.class})

अधिक जानकारी यहाँ

Question 4

टाइप कनवर्टर के लिए कोटलिन संस्करण:

 class Converters {

    @TypeConverter
    fun listToJson(value: List<JobWorkHistory>?) = Gson().toJson(value)

    @TypeConverter
    fun jsonToList(value: String) = Gson().fromJson(value, Array<JobWorkHistory>::class.java).toList()
}

मैंने JobWorkHistoryअपने उद्देश्य के लिए वस्तु का उपयोग किया, अपनी खुद की वस्तु का उपयोग किया

@Database(entities = arrayOf(JobDetailFile::class, JobResponse::class), version = 1)
@TypeConverters(Converters::class)
abstract class MyRoomDataBase : RoomDatabase() {
     abstract fun attachmentsDao(): AttachmentsDao
}

Question 5

List<String>कनवर्टर का बेहतर संस्करण

class StringListConverter {
    @TypeConverter
    fun fromString(stringListString: String): List<String> {
        return stringListString.split(",").map { it }
    }

    @TypeConverter
    fun toString(stringList: List<String>): String {
        return stringList.joinToString(separator = ",")
    }
}

Question 6

यह है कि मैं सूची रूपांतरण को कैसे संभालता हूं

public class GenreConverter {
@TypeConverter
public List<Integer> gettingListFromString(String genreIds) {
    List<Integer> list = new ArrayList<>();

    String[] array = genreIds.split(",");

    for (String s : array) {
       if (!s.isEmpty()) {
           list.add(Integer.parseInt(s));
       }
    }
    return list;
}

@TypeConverter
public String writingStringFromList(List<Integer> list) {
    String genreIds = "";
    for (int i : list) {
        genreIds += "," + i;
    }
    return genreIds;
}}

और फिर डेटाबेस पर मैं नीचे दिखाया गया है

@Database(entities = {MovieEntry.class}, version = 1)
@TypeConverters(GenreConverter.class)

और नीचे उसी का एक कोटलिन कार्यान्वयन है;

class GenreConverter {
@TypeConverter
fun gettingListFromString(genreIds: String): List<Int> {
    val list = mutableListOf<Int>()

    val array = genreIds.split(",".toRegex()).dropLastWhile {
        it.isEmpty()
    }.toTypedArray()

    for (s in array) {
        if (s.isNotEmpty()) {
            list.add(s.toInt())
        }
    }
    return list
}

@TypeConverter
fun writingStringFromList(list: List<Int>): String {
    var genreIds=""
    for (i in list) genreIds += ",$i"
    return genreIds
}}

Question 7

जैसा कि ऊपर वर्णित त्रुटि संदेश था। मैं जोड़ना चाहूंगा: यदि आपको यह त्रुटि संदेश किसी @Query में मिलता है, तो आपको @TypeConverters को @Query एनोटेशन से ऊपर जोड़ना चाहिए।

उदाहरण:

@TypeConverters(DateConverter.class)
@Query("update myTable set myDate=:myDate  where id = :myId")
void updateStats(int myId, Date myDate);

....

public class DateConverter {

    @TypeConverter
    public static Date toDate(Long timestamp) {
        return timestamp == null ? null : new Date(timestamp);
    }

    @TypeConverter
    public static Long toTimestamp(Date date) {
        return date == null ? null : date.getTime();
    }
}

Question 8

मैं व्यक्तिगत रूप से @TypeConverters/ क्रमबद्धता के खिलाफ सलाह दूंगा, क्योंकि वे डेटाबेस के सामान्य रूपों के अनुपालन को तोड़ते हैं।

इस विशेष मामले के लिए, यह @Relation एनोटेशन का उपयोग करते हुए किसी रिश्ते को परिभाषित करने के लायक हो सकता है , जो सभी SQL प्रश्नों को मैन्युअल रूप से घोषित करने और लिखने की अतिरिक्त जटिलता के बिना नेस्टेड संस्थाओं को क्वेरी करने की अनुमति देता है :@ForeignKey

@Entity
public class MainActivityData {
    @PrimaryKey
    private String userId;
    private String itemOneId;
    private String itemTwoId;
}

@Entity
public class MyListItem {
    @PrimaryKey
    public int id;
    public String ownerUserId;
    public String text;
}

/* This is the class we use to define our relationship,
   which will also be used to return our query results.
   Note that it is not defined as an @Entity */
public class DataWithItems {
    @Embedded public MainActivityData data;
    @Relation(
        parentColumn = "userId"
        entityColumn = "ownerUserId"
    )
    public List<MyListItem> myListItems;
}

/* This is the DAO interface where we define the queries.
   Even though it looks like a single SELECT, Room performs
   two, therefore the @Transaction annotation is required */
@Dao
public interface ListItemsDao {
    @Transaction
    @Query("SELECT * FROM MainActivityData")
    public List<DataWithItems> getAllData();
}

इस 1-एन उदाहरण के अलावा, 1-1 और एनएम संबंधों को भी परिभाषित करना संभव है।

Question 9

कोटलिन के क्रमांकन घटक - kotlinx.serialization का उपयोग करके मूल कोटलिन संस्करण ।

कोटलिन क्रमांकन ग्रेड प्लग और निर्भरता को अपने में जोड़ें build.gradle:

apply plugin: 'kotlinx-serialization'

dependencies {
   ...
   implementation "org.jetbrains.kotlinx:kotlinx-serialization-json:1.0.1"
}

अपने कन्वर्टर वर्ग में टाइप कन्वर्टर्स जोड़ें;

@TypeConverter
fun fromList(value : List<String>) = Json.encodeToString(value)

@TypeConverter
fun toList(value: String) = Json.decodeFromString<List<String>>(value)

अपने डेटाबेस वर्ग में अपने कनवर्टर वर्ग को जोड़ें:

@TypeConverters(Converters::class)
abstract class YourDatabase: RoomDatabase() {...}

और आपने कल लिया!

अतिरिक्त संसाधन:

Question 10

यह उत्तर कॉटिन को कॉमा द्वारा विभाजित करने और कॉमा डीलिनेटेड स्ट्रिंग के निर्माण के लिए उपयोग करता है। अल्पविराम को सभी लेकिन अंतिम तत्व के अंत में जाने की आवश्यकता है, इसलिए यह एकल तत्व सूचियों को भी संभाल लेगा।

object StringListConverter {
        @TypeConverter
        @JvmStatic
        fun toList(strings: String): List<String> {
            val list = mutableListOf<String>()
            val array = strings.split(",")
            for (s in array) {
                list.add(s)
            }
            return list
        }

        @TypeConverter
        @JvmStatic
        fun toString(strings: List<String>): String {
            var result = ""
            strings.forEachIndexed { index, element ->
                result += element
                if(index != (strings.size-1)){
                    result += ","
                }
            }
            return result
        }
    }

Question 11

मेरे मामले में समस्या इस उत्तर पर सामान्य प्रकार का आधार थी

ArstList के बजाय https://stackoverflow.com/a/48480257/3675925 उपयोग सूची

 import androidx.room.TypeConverter
 import com.google.gson.Gson 
 import com.google.gson.reflect.TypeToken
 class IntArrayListConverter {
     @TypeConverter
     fun fromString(value: String): List<Int> {
         val type = object: TypeToken<List<Int>>() {}.type
         return Gson().fromJson(value, type)
     }

     @TypeConverter
     fun fromArrayList(list: List<Int>): String {
         val type = object: TypeToken<List<Int>>() {}.type
         return Gson().toJson(list, type)
     } 
}

इसमें डाओ क्लास में क्वेरी करने के लिए @TypeConverters (IntArrayListConverter :: class) जोड़ने की जरूरत नहीं है और न ही एंटिटी क्लास में फील्ड और सिर्फ डेटाबेस क्लास में @TypeConverters (IntArrayListConverter) क्लास जोड़ें।

@Database(entities = [MyEntity::class], version = 1, exportSchema = false)
@TypeConverters(IntArrayListConverter::class)
abstract class MyDatabase : RoomDatabase() {

Question 12

@TypeConvertersParams के रूप में कनवर्टर वर्ग के साथ जोड़ना

डेटाबेस और दाओ वर्ग के लिए, मेरे प्रश्नों ने काम किया

Question 13

स्मृति रूपांतरण के संदर्भ में Json रूपांतरण अच्छी तरह से पैमाने पर नहीं है। मैं कुछ अशक्तता के साथ प्रतिक्रियाओं के समान कुछ के लिए जाना होगा।

class Converters {
    @TypeConverter
    fun stringAsStringList(strings: String?): List<String> {
        val list = mutableListOf<String>()
        strings
            ?.split(",")
            ?.forEach {
                list.add(it)
            }

        return list
    }

    @TypeConverter
    fun stringListAsString(strings: List<String>?): String {
        var result = ""
        strings?.forEach { element ->
            result += "$element,"
        }
        return result.removeSuffix(",")
    }
}

सरल डेटा प्रकारों के लिए उपरोक्त का उपयोग किया जा सकता है, अन्यथा जटिल डेटाटाइप्स के लिए कक्ष एंबेडेड प्रदान करता है

Question 14

यहाँ CustomObject प्रकार को कक्ष DB तालिका में जोड़ने के लिए उदाहरण दिया गया है। https://mobikul.com/insert-custom-list-and-get-that-list-in-room-database-using-typeconverter/

एक प्रकार का कनवर्टर जोड़ना आसान था, मुझे बस एक ऐसी विधि की आवश्यकता थी जो वस्तुओं की सूची को एक स्ट्रिंग में बदल सकती है, और एक विधि जो रिवर्स कर सकती है। मैंने इसके लिए गेसन का इस्तेमाल किया।

public class Converters {

    @TypeConverter
    public static String MyListItemListToString(List<MyListitem> list) {
        Gson gson = new Gson();
        return gson.toJson(list);
    }

    @TypeConverter
    public static List<Integer> stringToMyListItemList(@Nullable String data) {
        if (data == null) {
            return Collections.emptyList();
        }

        Type listType = new TypeToken<List<MyListItem>>() {}.getType();

        Gson gson = new Gson();
        return gson.fromJson(data, listType);
    }
}

मैंने तब एंटिटी में फ़ील्ड में एक एनोटेशन जोड़ा:

@TypeConverters(Converters.class)

public final ArrayList<MyListItem> myListItems;

Question 15

जब हम TypaConverters का उपयोग करके r करते हैं तो डेटाटाइप को TypeConverter विधि का रिटर्न प्रकार होना चाहिए। उदाहरण TypeConverter विधि रिटर्न स्ट्रिंग तो जोड़ना तालिका COloum स्ट्रिंग होना चाहिए

 private static final Migration MIGRATION_1_2 = new Migration(1, 2) {
    @Override
    public void migrate(@NonNull SupportSQLiteDatabase database) {
        // Since we didn't alter the table, there's nothing else to do here.
        database.execSQL("ALTER TABLE "+  Collection.TABLE_STATUS  + " ADD COLUMN deviceType TEXT;");
        database.execSQL("ALTER TABLE "+  Collection.TABLE_STATUS  + " ADD COLUMN inboxType TEXT;");
    }
};

Question 16

 @Query("SELECT * FROM business_table")
 abstract List<DatabaseModels.Business> getBusinessInternal();


 @Transaction @Query("SELECT * FROM business_table")
 public ArrayList<DatabaseModels.Business> getBusiness(){
        return new ArrayList<>(getBusinessInternal());
 }

Question 17

उपरोक्त सभी उत्तर तार की सूची के लिए है। लेकिन नीचे आपको अपनी वस्तुओं की सूची के लिए कनवर्टर खोजने में मदद करता है।

" YourClassName " के स्थान पर , अपनी ऑब्जेक्ट क्लास जोड़ें।

 @TypeConverter
        public String fromValuesToList(ArrayList<**YourClassName**> value) {
            if (value== null) {
                return (null);
            }
            Gson gson = new Gson();
            Type type = new TypeToken<ArrayList<**YourClassName**>>() {}.getType();
            return gson.toJson(value, type);
        }
    
        @TypeConverter
        public ArrayList<**YourClassName**> toOptionValuesList(String value) {
            if (value== null) {
                return (null);
            }
            Gson gson = new Gson();
            Type type = new TypeToken<List<**YourClassName**>>() {
            }.getType();
            return gson.fromJson(value, type);
        }

Question 18

उपरोक्त सभी उत्तर सही हैं। हां, यदि आपको किसी SQLite फ़ील्ड में किसी चीज़ के स्टोर सरणी की आवश्यकता है तो TypeConverter एक समाधान है।

और मैंने अपनी परियोजनाओं में स्वीकृत उत्तर का उपयोग किया।

लेकिन यह मत करो !!!

यदि आपको 90% मामलों में इकाई में स्टोर सरणी की आवश्यकता है तो आपको एक-से-कई या कई-से-कई संबंध बनाने की आवश्यकता है।

अन्यथा, इस सरणी के अंदर कुंजी के साथ कुछ का चयन करने के लिए आपकी अगली SQL क्वेरी बिल्कुल नरक होगी ...

उदाहरण:

ऑब्जेक्ट फू जूसन के रूप में आता है: [{आईडी: 1, नाम: "एब्स"}, {आईडी: 2, नाम: "शेड"}

ऑब्जेक्ट बार: [{id, 1, foos: [1, 2], {...}]

तो इस तरह से इकाई न बनाएं:

@Entity....
data class bar(
...
val foos: ArrayList<Int>)

अगले की तरह बनाएं:

@Entity(tablename="bar_foo", primaryKeys=["fooId", "barId"])
data class barFoo(val barId: Int, val fooId: Int)

और अपने झोले में झांका: [] इस तालिका में रिकॉर्ड के रूप में।

Question 19

कमरे से आधिकारिक समाधान का उपयोग करें, @ एंबेडेड एनोटेशन:

@Embedded(prefix = "mylist_array") private ArrayList<MyListItems> myListItems