ऑब्जेक्ट के बीच का संबंध बताना

SQLite एक रिलेशनल डेटाबेस है, इसलिए दो अलग-अलग सोर्स के बीच के संबंध को समझा जा सकता है इकाइयां. हालांकि, ज़्यादातर ऑब्जेक्ट-रिलेशनल मैपिंग लाइब्रेरी, ऑब्जेक्ट एक-दूसरे का रेफ़रंस देते हैं, रूम साफ़ तौर पर इसकी अनुमति नहीं देता. इसके बारे में जानने के लिए इस फ़ैसले के पीछे की तकनीकी वजहों के बारे में जानने के लिए, यह समझना कि कमरा क्यों नहीं ऑब्जेक्ट के रेफ़रंस की अनुमति दें.

दो संभावित तरीके

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

इंटरमीडिएट डेटा क्लास

इंटरमीडिएट डेटा क्लास अप्रोच में, एक ऐसा डेटा क्लास तय किया जाता है जो रूम की इकाइयों के बीच संबंध. इस डेटा क्लास में पेयरिंग होती हैं के बीच एक इकाई और दूसरी इकाई के, एम्बेड की गई चीज़ें. इसके बाद, आपके क्वेरी के तरीकों में इस तरह के इंस्टेंस दिखाए जा सकते हैं डेटा क्लास का इस्तेमाल करें.

उदाहरण के लिए, लाइब्रेरी के उपयोगकर्ताओं को दिखाने के लिए, UserBook डेटा क्लास को तय किया जा सकता है जिसमें चेक आउट की गई हो, और डेटाबेस से UserBook इंस्टेंस:

@Dao
interface UserBookDao {
    @Query(
        "SELECT user.name AS userName, book.name AS bookName " +
        "FROM user, book " +
        "WHERE user.id = book.user_id"
    )
    fun loadUserAndBookNames(): LiveData<List<UserBook>>
}

data class UserBook(val userName: String?, val bookName: String?)

@Dao
public interface UserBookDao {
   @Query("SELECT user.name AS userName, book.name AS bookName " +
          "FROM user, book " +
          "WHERE user.id = book.user_id")
   public LiveData<List<UserBook>> loadUserAndBookNames();
}

public class UserBook {
    public String userName;
    public String bookName;
}

मल्टीमैप के रिटर्न टाइप

मल्टीमैप रिटर्न टाइप अप्रोच में, आपको कोई अतिरिक्त डेटा क्लास का इस्तेमाल करता है. इसके बजाय, आप multimap रिटर्न टाइप जो आपको मैप के स्ट्रक्चर के मुताबिक बनाना है. साथ ही, सीधे आपकी SQL क्वेरी में अपनी इकाइयों के बीच में बदलाव करें.

उदाहरण के लिए, क्वेरी का यह तरीका User और Book की मैपिंग दिखाता है उदाहरण के लिए, लाइब्रेरी के उन उपयोगकर्ताओं को दिखाने के लिए इंस्टेंस जिन्हें खास तौर पर चेक आउट किया गया है:

@Query(
    "SELECT * FROM user" +
    "JOIN book ON user.id = book.user_id"
)
fun loadUserAndBookNames(): Map<User, List<Book>>

@Query(
    "SELECT * FROM user" +
    "JOIN book ON user.id = book.user_id"
)
public Map<User, List<Book>> loadUserAndBookNames();

कोई तरीका चुनें

रूम में इन दोनों तरीकों का इस्तेमाल किया जा सकता है. इसलिए, इनका इस्तेमाल किया जा सकता है जो तरीका आपके ऐप्लिकेशन के लिए सबसे सही हो. इस सेक्शन में, आपको इनमें से किसी एक को क्यों चुनना चाहिए.

इंटरमीडिएट डेटा क्लास वाले तरीके से, जटिल एसक्यूएल लिखने से बचा जा सकता है क्वेरी पूछ सकते हैं, लेकिन इसकी वजह से कोड की जटिलता भी बढ़ सकती है की ज़रूरत होती है. कम शब्दों में कहें, तो मल्टीमैप पर रिटर्न टाइप काम करने का तरीका चुनने के लिए, आपकी एसक्यूएल क्वेरी को ज़्यादा काम करना होगा. साथ ही, इंटरमीडिएट डेटा को क्लास अप्रोच को और काम करने के लिए, आपके कोड की ज़रूरत होती है.

अगर आपके पास इंटरमीडिएट डेटा क्लास इस्तेमाल करने की कोई खास वजह नहीं है, तो हम मल्टीमैप पर रिटर्न टाइप का इस्तेमाल करने का सुझाव दिया जाता है. इस बारे में ज़्यादा जानने के लिए देखने के लिए, एक मल्टीमैप शामिल करें.

इस गाइड के बाकी हिस्से में बताया गया है कि इंटरमीडिएट डेटा क्लास अप्रोच का इस्तेमाल करें.

एम्बेड किए गए ऑब्जेक्ट बनाना

कभी-कभी, किसी इकाई या डेटा ऑब्जेक्ट को आपके डेटाबेस लॉजिक में पूरी जानकारी एक ही जगह पर मौजूद होती है. भले ही, ऑब्जेक्ट में कई फ़ील्ड. इन स्थितियों में, आपके पास @Embedded एनोटेशन है जो उस ऑब्जेक्ट को दिखाता है जिसे आपको डिकोड करना है सबफ़ील्ड का इस्तेमाल कर सकते हैं. इसके बाद, एम्बेड किए गए फ़ील्ड से ठीक वैसे ही क्वेरी की जा सकती है का इस्तेमाल करें.

उदाहरण के लिए, आपकी User क्लास में Address टाइप का फ़ील्ड शामिल हो सकता है जो street, city, state, और नाम के फ़ील्ड की कंपोज़िशन को दिखाता है postCode. बनाए गए कॉलम को टेबल में अलग से सेव करने के लिए, कॉलम में User क्लास का Address फ़ील्ड, जिसके साथ एनोटेट किया गया है @Embedded के तौर पर निम्न कोड स्निपेट में दिखाया गया है:

data class Address(
    val street: String?,
    val state: String?,
    val city: String?,
    @ColumnInfo(name = "post_code") val postCode: Int
)

@Entity
data class User(
    @PrimaryKey val id: Int,
    val firstName: String?,
    @Embedded val address: Address?
)

public class Address {
    public String street;
    public String state;
    public String city;

    @ColumnInfo(name = "post_code") public int postCode;
}

@Entity
public class User {
    @PrimaryKey public int id;

    public String firstName;

    @Embedded public Address address;
}

User ऑब्जेक्ट को दिखाने वाली टेबल में, इन कॉलम वाले कॉलम शामिल हैं नाम: id, firstName, street, state, city, और post_code.

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

वन-टू-वन रिलेशनशिप तय करना

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

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

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

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

@Entity
data class Library(
    @PrimaryKey val libraryId: Long,
    val userOwnerId: Long
)

@Entity
public class User {
    @PrimaryKey public long userId;
    public String name;
    public int age;
}

@Entity
public class Library {
    @PrimaryKey public long libraryId;
    public long userOwnerId;
}

उपयोगकर्ताओं की सूची और उससे जुड़ी लाइब्रेरी के बारे में क्वेरी करने के लिए, सबसे पहले दो इकाइयों के बीच वन-टू-वन संबंध का मॉडल बनाएं. ऐसा करने के लिए, नई डेटा क्लास, जहां हर इंस्टेंस में पैरंट इकाई का कोई इंस्टेंस होता है और चाइल्ड इकाई का संबंधित इंस्टेंस. @Relation जोड़ें चाइल्ड इकाई के इंस्टेंस की व्याख्या, जिसमें parentColumn इस पर सेट है पैरंट इकाई के प्राथमिक कुंजी कॉलम का नाम और entityColumn चाइल्ड इकाई के कॉलम के नाम पर सेट करें, जो पैरंट का रेफ़रंस देता है इकाई की प्राथमिक कुंजी है.

data class UserAndLibrary(
    @Embedded val user: User,
    @Relation(
         parentColumn = "userId",
         entityColumn = "userOwnerId"
    )
    val library: Library
)

public class UserAndLibrary {
    @Embedded public User user;
    @Relation(
         parentColumn = "userId",
         entityColumn = "userOwnerId"
    )
    public Library library;
}

आखिर में, डीएओ क्लास में ऐसा तरीका जोड़ें जो डेटा के सभी इंस्टेंस दिखाता हो क्लास, जो पैरंट इकाई और चाइल्ड इकाई को जोड़ती है. इस तरीके का इस्तेमाल करने के लिए, यह ज़रूरी है दो क्वेरी चलाने के लिए कमरा, इसलिए इसमें @Transaction एनोटेशन जोड़ें तरीका है, ताकि पूरा काम अपने तरीके से हो.

@Transaction
@Query("SELECT * FROM User")
fun getUsersAndLibraries(): List<UserAndLibrary>

@Transaction
@Query("SELECT * FROM User")
public List<UserAndLibrary> getUsersAndLibraries();

वन-टू-मेनी रिलेशनशिप को परिभाषित करना

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

संगीत स्ट्रीमिंग ऐप्लिकेशन के उदाहरण में, मान लें कि उपयोगकर्ता अपने गानों की प्लेलिस्ट बनाना. हर व्यक्ति जितनी चाहें उतनी प्लेलिस्ट बना सकता है, लेकिन हर प्लेलिस्ट सिर्फ़ एक उपयोगकर्ता ने बनाई है. इसलिए, 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
)

@Entity
public class User {
    @PrimaryKey public long userId;
    public String name;
    public int age;
}

@Entity
public class Playlist {
    @PrimaryKey public long playlistId;
    public long userCreatorId;
    public String playlistName;
}

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

data class UserWithPlaylists(
    @Embedded val user: User,
    @Relation(
          parentColumn = "userId",
          entityColumn = "userCreatorId"
    )
    val playlists: List<Playlist>
)

public class UserWithPlaylists {
    @Embedded public User user;
    @Relation(
         parentColumn = "userId",
         entityColumn = "userCreatorId"
    )
    public List<Playlist> playlists;
}

आखिर में, डीएओ क्लास में ऐसा तरीका जोड़ें जो डेटा के सभी इंस्टेंस दिखाता हो क्लास, जो पैरंट इकाई और चाइल्ड इकाई को जोड़ती है. इस तरीके का इस्तेमाल करने के लिए, यह ज़रूरी है दो क्वेरी चलाने के लिए कमरा, इसलिए इसमें @Transaction एनोटेशन जोड़ें तरीका है, ताकि पूरा काम अपने तरीके से हो.

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

@Transaction
@Query("SELECT * FROM User")
public List<UserWithPlaylists> getUsersWithPlaylists();

मेनी-टू-मेनी संबंध तय करना

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

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

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

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

@Entity
data class Song(
    @PrimaryKey val songId: Long,
    val songName: String,
    val artist: String
)

@Entity(primaryKeys = ["playlistId", "songId"])
data class PlaylistSongCrossRef(
    val playlistId: Long,
    val songId: Long
)

@Entity
public class Playlist {
    @PrimaryKey public long playlistId;
    public String playlistName;
}

@Entity
public class Song {
    @PrimaryKey public long songId;
    public String songName;
    public String artist;
}

@Entity(primaryKeys = {"playlistId", "songId"})
public class PlaylistSongCrossRef {
    public long playlistId;
    public long songId;
}

अगला चरण इस बात पर निर्भर करता है कि आपको इन मिलती-जुलती इकाइयों के लिए क्वेरी कैसे करनी है.

• अगर आपको प्लेलिस्ट और उनसे जुड़े गाने की सूची के बारे में क्वेरी करनी है, तो हर प्लेलिस्ट के लिए, एक नई डेटा क्लास बनाएं, जिसमें एक Playlist ऑब्जेक्ट हो उन सभी Song ऑब्जेक्ट की सूची जिन्हें प्लेलिस्ट में शामिल किया गया है.
• अगर आपको गाने और उनसे जुड़ी प्लेलिस्ट की सूची के बारे में क्वेरी करनी है, तो हर एक, एक नई डेटा क्लास बनाएं, जिसमें एक Song ऑब्जेक्ट और एक सूची हो उन सभी Playlist ऑब्जेक्ट का प्रतिशत जिनमें गाना शामिल है.

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

data class PlaylistWithSongs(
    @Embedded val playlist: Playlist,
    @Relation(
         parentColumn = "playlistId",
         entityColumn = "songId",
         associateBy = Junction(PlaylistSongCrossRef::class)
    )
    val songs: List<Song>
)

data class SongWithPlaylists(
    @Embedded val song: Song,
    @Relation(
         parentColumn = "songId",
         entityColumn = "playlistId",
         associateBy = Junction(PlaylistSongCrossRef::class)
    )
    val playlists: List<Playlist>
)

public class PlaylistWithSongs {
    @Embedded public Playlist playlist;
    @Relation(
         parentColumn = "playlistId",
         entityColumn = "songId",
         associateBy = @Junction(PlaylistSongCrossref.class)
    )
    public List<Song> songs;
}

public class SongWithPlaylists {
    @Embedded public Song song;
    @Relation(
         parentColumn = "songId",
         entityColumn = "playlistId",
         associateBy = @Junction(PlaylistSongCrossref.class)
    )
    public List<Playlist> playlists;
}

आखिर में, अपने क्वेरी फ़ंक्शन को सार्वजनिक करने के लिए डीएओ क्लास में कोई तरीका जोड़ें ज़रूरत है.

• getPlaylistsWithSongs: यह तरीका डेटाबेस से क्वेरी करता है और सभी नतीजे दिखाता है इससे PlaylistWithSongs ऑब्जेक्ट बनेगा.
• getSongsWithPlaylists: यह तरीका डेटाबेस से क्वेरी करता है और सभी नतीजे दिखाता है इससे SongWithPlaylists ऑब्जेक्ट बनेगा.

इन तरीकों में, दो क्वेरी चलाने के लिए रूम की ज़रूरत होती है. इसलिए, @Transaction दोनों तरीकों से एनोटेशन बनाएं, ताकि पूरा काम उसी तरीके से किया जाता है.

@Transaction
@Query("SELECT * FROM Playlist")
fun getPlaylistsWithSongs(): List<PlaylistWithSongs>

@Transaction
@Query("SELECT * FROM Song")
fun getSongsWithPlaylists(): List<SongWithPlaylists>

@Transaction
@Query("SELECT * FROM Playlist")
public List<PlaylistWithSongs> getPlaylistsWithSongs();

@Transaction
@Query("SELECT * FROM Song")
public List<SongWithPlaylists> getSongsWithPlaylists();

नेस्ट किए गए संबंधों को तय करना

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

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

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

@Entity
data class Song(
    @PrimaryKey val songId: Long,
    val songName: String,
    val artist: String
)

@Entity(primaryKeys = ["playlistId", "songId"])
data class PlaylistSongCrossRef(
    val playlistId: Long,
    val songId: Long
)

@Entity
public class User {
    @PrimaryKey public long userId;
    public String name;
    public int age;
}

@Entity
public class Playlist {
    @PrimaryKey public long playlistId;
    public long userCreatorId;
    public String playlistName;
}
@Entity
public class Song {
    @PrimaryKey public long songId;
    public String songName;
    public String artist;
}

@Entity(primaryKeys = {"playlistId", "songId"})
public class PlaylistSongCrossRef {
    public long playlistId;
    public long songId;
}

सबसे पहले, अपने सेट की दो टेबल के बीच के संबंध का मॉडल बनाएं आम तौर पर, डेटा क्लास और @Relation एनोटेशन. कॉन्टेंट बनाने नीचे दिए गए उदाहरण में, एक PlaylistWithSongs क्लास दिखाई गई है, जो मेनी-टू-मेनी मॉडल करती है Playlist इकाई क्लास और Song इकाई क्लास के बीच संबंध:

data class PlaylistWithSongs(
    @Embedded val playlist: Playlist,
    @Relation(
         parentColumn = "playlistId",
         entityColumn = "songId",
         associateBy = Junction(PlaylistSongCrossRef::class)
    )
    val songs: List<Song>
)

public class PlaylistWithSongs {
    @Embedded public Playlist playlist;
    @Relation(
         parentColumn = "playlistId",
         entityColumn = "songId",
         associateBy = Junction(PlaylistSongCrossRef.class)
    )
    public List<Song> songs;
}

इस संबंध को दिखाने वाली डेटा क्लास के बारे में बताने के बाद, दूसरा बनाएं वह डेटा क्लास जो आपके सेट और आपके सेट की किसी अन्य टेबल के बीच के संबंध का मॉडल तैयार करती है फ़र्स्ट रिलेशनशिप क्लास, "नेस्टिंग" नए कानून के साथ मौजूदा संबंध एक. इस उदाहरण में, UserWithPlaylistsAndSongs क्लास के बारे में बताया गया है, जो User इकाई क्लास और PlaylistWithSongs संबंध श्रेणी:

data class UserWithPlaylistsAndSongs(
    @Embedded val user: User
    @Relation(
        entity = Playlist::class,
        parentColumn = "userId",
        entityColumn = "userCreatorId"
    )
    val playlists: List<PlaylistWithSongs>
)

public class UserWithPlaylistsAndSongs {
    @Embedded public User user;
    @Relation(
        entity = Playlist.class,
        parentColumn = "userId",
        entityColumn = "userCreatorId"
    )
    public List<PlaylistWithSongs> playlists;
}

UserWithPlaylistsAndSongs क्लास सीधे तौर पर, रिलेशनशिप को मॉडल करती है इकाई की तीनों क्लास के बीच में: User, Playlist, और Song. यह है पहली इमेज में दिखाया गया है.

पहला डायग्राम. इस डायग्राम में संबंध वर्गों का डायग्राम संगीत स्ट्रीमिंग ऐप्लिकेशन का उदाहरण.

अगर आपके सेट में और टेबल हैं, तो बची हुई हर टेबल और उस रिलेशनशिप क्लास के बीच संबंध जो मॉडल करती है पिछली सभी टेबल के बीच का संबंध. इससे नेस्ट की गई एक चेन कई टेबल के बीच के संबंधों को दिखाया जाता है.

आखिर में, डीएओ क्लास में एक तरीका जोड़ें, ताकि क्वेरी फ़ंक्शन का पता चल सके जो आपके ऐप्लिकेशन की ज़रूरतें पूरी होती हैं. इस तरीके में एक से ज़्यादा क्वेरी चलाने के लिए रूम की ज़रूरत होती है, इसलिए @Transaction एनोटेशन इससे पूरा काम अपने तरीके से होता है:

@Transaction
@Query("SELECT * FROM User")
fun getUsersWithPlaylistsAndSongs(): List<UserWithPlaylistsAndSongs>

@Transaction
@Query("SELECT * FROM User")
public List<UserWithPlaylistsAndSongs> getUsersWithPlaylistsAndSongs();

अन्य संसाधन

रूम में इकाइयों के बीच संबंध तय करने के बारे में ज़्यादा जानने के लिए, यहां देखें: इन अतिरिक्त संसाधनों को देखें.

सैंपल

• Android सनफ़्लावर
• तिवी

वीडियो

• रूम में नया क्या है (Android Dev सम्मेलन '19)

ब्लॉग

• इसके साथ डेटाबेस संबंध कमरा