Google आपकी पसंदीदा भाषा में कॉन्टेंट का अनुवाद करने के लिए, एआई टेक्नोलॉजी का इस्तेमाल करता है. एआई से मिले अनुवादों में गलतियां हो सकती हैं.

एक-से-कई रिलेशनशिप तय करना और उनसे जुड़ी क्वेरी करना

दो एंटिटी के बीच एक-से-कई का संबंध ऐसा संबंध होता है जिसमें पैरंट एंटिटी का हर इंस्टेंस, चाइल्ड एंटिटी के शून्य या उससे ज़्यादा इंस्टेंस से मेल खाता है. हालांकि, चाइल्ड एंटिटी का हर इंस्टेंस, पैरंट एंटिटी के सिर्फ़ एक इंस्टेंस से मेल खा सकता है.

म्यूज़िक स्ट्रीमिंग ऐप्लिकेशन के उदाहरण में, मान लें कि उपयोगकर्ता अपने गानों को प्लेलिस्ट में व्यवस्थित कर सकता है. हर उपयोगकर्ता, अपनी पसंद के मुताबिक जितनी चाहे उतनी प्लेलिस्ट बना सकता है. हालांकि, हर प्लेलिस्ट को सिर्फ़ एक उपयोगकर्ता बनाता है. इसलिए, User एंटिटी और Playlist एंटिटी के बीच एक-से-कई का संबंध होता है.

अपने डेटाबेस में एक-से-कई के संबंध तय करने और उनके बारे में क्वेरी करने के लिए, यह तरीका अपनाएं:

संबंध तय करना: दोनों एंटिटी के लिए क्लास बनाएं, इसमें चाइल्ड एंटिटी, पैरंट की प्राइमरी की को रेफ़र करती है.
एंटिटी के बारे में क्वेरी करना: किसी नई डेटा क्लास में संबंध को मॉडल करें और उससे जुड़ा डेटा पाने के लिए, एक फ़ंक्शन लागू करें.

संबंध तय करना

एक-से-कई का संबंध तय करने के लिए, सबसे पहले हर एंटिटी के लिए एक क्लास बनाएं. एक-से-एक के संबंध की तरह, चाइल्ड एंटिटी में एक ऐसा वैरिएबल शामिल होना चाहिए जो पैरंट एंटिटी की प्राइमरी की को रेफ़र करता हो.

@Entity
data class User(
    @PrimaryKey val userId: Long,
    val name: String,
    val age: Int
)

@Entity
data class Playlist(
    @PrimaryKey val playlistId: Long,
    val userCreatorId: Long,
    val playlistName: String
)OneToManySimpleSnippets.kt

एंटिटी के बारे में क्वेरी करना

उपयोगकर्ताओं की सूची और उनसे जुड़ी प्लेलिस्ट के बारे में क्वेरी करने के लिए, आपको सबसे पहले दोनों एंटिटी के बीच एक-से-कई के संबंध को मॉडल करना होगा.

संबंध को मॉडल करने के लिए, एक नई डेटा क्लास बनाएं. इस क्लास के हर इंस्टेंस में, पैरंट एंटिटी का एक इंस्टेंस और उससे जुड़े चाइल्ड एंटिटी के सभी इंस्टेंस की सूची होती है. चाइल्ड एंटिटी की सूची दिखाने वाली प्रॉपर्टी में, @Relation एनोटेशन जोड़ें. parentColumns को पैरंट एंटिटी की प्राइमरी की वाले कॉलम के नाम पर सेट करें. साथ ही, entityColumns को चाइल्ड एंटिटी के उस कॉलम के नाम पर सेट करें जो पैरंट एंटिटी की प्राइमरी की को रेफ़र करता है.

data class UserWithPlaylists(
    @Embedded val user: User,
    @Relation(
        parentColumns = ["userId"],
        entityColumns = ["userCreatorId"]
    )
    val playlists: List<Playlist>
)OneToManySimpleSnippets.kt

आखिर में, डेटा ऐक्सेस ऑब्जेक्ट (DAO) क्लास में एक ऐसा फ़ंक्शन जोड़ें जो पैरंट एंटिटी और चाइल्ड एंटिटी को पेयर करने वाली डेटा क्लास के सभी इंस्टेंस दिखाता है. @Transaction एनोटेशन जोड़ें, ताकि Room पूरी कार्रवाई को एटॉमिक तरीके से करे. यह एनोटेशन ज़रूरी है, क्योंकि फ़ंक्शन के लिए Room को दो क्वेरी चलाने की ज़रूरत होती है.

@Transaction
@Query("SELECT * FROM User")
suspend fun getUsersWithPlaylists(): List<UserWithPlaylists>OneToManySimpleSnippets.kt

कंपोज़िट की

अगर कंपोज़िट की का इस्तेमाल करके संबंध तय किया जाता है, तो parentColumns और entityColumns में एक से ज़्यादा कॉलम तय करें. parentColumns में कॉलम का क्रम, entityColumns में कॉलम के क्रम से मेल खाना चाहिए.

@Entity(primaryKeys = ["firstName", "lastName"])
data class User(
    val firstName: String,
    val lastName: String,
    val age: Int
)

@Entity
data class Playlist(
    @PrimaryKey val playlistId: Long,
    val userFirstName: String,
    val userLastName: String,
    val playlistName: String
)

data class UserWithPlaylists(
    @Embedded val user: User,
    @Relation(
        parentColumns = ["firstName", "lastName"],
        entityColumns = ["userFirstName", "userLastName"]
    )
    val playlists: List<Playlist>
)OneToManyCompositeSnippets.kt