SQLite एक रिलेशनल डेटाबेस है, इसलिए दो अलग-अलग सोर्स के बीच के संबंध को समझा जा सकता है इकाइयां. हालांकि, ज़्यादातर ऑब्जेक्ट-रिलेशनल मैपिंग लाइब्रेरी, ऑब्जेक्ट एक-दूसरे का रेफ़रंस देते हैं, रूम साफ़ तौर पर इसकी अनुमति नहीं देता. इसके बारे में जानने के लिए इस फ़ैसले के पीछे की तकनीकी वजहों के बारे में जानने के लिए, यह समझना कि कमरा क्यों नहीं ऑब्जेक्ट के रेफ़रंस की अनुमति दें.
दो संभावित तरीके
रूम में, इकाइयों के बीच संबंध तय करने और उसके बारे में क्वेरी करने के दो तरीके हैं: इंटरमीडिएट डेटा क्लास का इस्तेमाल करके एम्बेड किए गए ऑब्जेक्ट या मल्टीमैप रिटर्न के साथ रिलेशनल क्वेरी मेथड टाइप करें.
इंटरमीडिएट डेटा क्लास
इंटरमीडिएट डेटा क्लास अप्रोच में, एक ऐसा डेटा क्लास तय किया जाता है जो रूम की इकाइयों के बीच संबंध. इस डेटा क्लास में पेयरिंग होती हैं के बीच एक इकाई और दूसरी इकाई के, एम्बेड की गई चीज़ें. इसके बाद, आपके क्वेरी के तरीकों में इस तरह के इंस्टेंस दिखाए जा सकते हैं डेटा क्लास का इस्तेमाल करें.
उदाहरण के लिए, लाइब्रेरी के उपयोगकर्ताओं को दिखाने के लिए, UserBook
डेटा क्लास को तय किया जा सकता है
जिसमें चेक आउट की गई हो, और
डेटाबेस से UserBook
इंस्टेंस:
Kotlin
@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?)
Java
@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
की मैपिंग दिखाता है
उदाहरण के लिए, लाइब्रेरी के उन उपयोगकर्ताओं को दिखाने के लिए इंस्टेंस जिन्हें खास तौर पर चेक आउट किया गया है:
Kotlin
@Query( "SELECT * FROM user" + "JOIN book ON user.id = book.user_id" ) fun loadUserAndBookNames(): Map<User, List<Book>>
Java
@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
के तौर पर
निम्न कोड स्निपेट में दिखाया गया है:
Kotlin
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? )
Java
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
इकाई के बीच संबंध.
एक-से-एक संबंध तय करने के लिए, पहले अपने दोनों में से प्रत्येक के लिए एक क्लास बनाएं इकाइयां. इकाइयों में से एक को एक ऐसा वैरिएबल शामिल करें जो दूसरी इकाई की प्राथमिक कुंजी का रेफ़रंस हो.
Kotlin
@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 )
Java
@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
चाइल्ड इकाई के कॉलम के नाम पर सेट करें, जो पैरंट का रेफ़रंस देता है
इकाई की प्राथमिक कुंजी है.
Kotlin
data class UserAndLibrary( @Embedded val user: User, @Relation( parentColumn = "userId", entityColumn = "userOwnerId" ) val library: Library )
Java
public class UserAndLibrary { @Embedded public User user; @Relation( parentColumn = "userId", entityColumn = "userOwnerId" ) public Library library; }
आखिर में, डीएओ क्लास में ऐसा तरीका जोड़ें जो डेटा के सभी इंस्टेंस दिखाता हो
क्लास, जो पैरंट इकाई और चाइल्ड इकाई को जोड़ती है. इस तरीके का इस्तेमाल करने के लिए, यह ज़रूरी है
दो क्वेरी चलाने के लिए कमरा, इसलिए इसमें @Transaction
एनोटेशन जोड़ें
तरीका है, ताकि पूरा काम अपने तरीके से हो.
Kotlin
@Transaction @Query("SELECT * FROM User") fun getUsersAndLibraries(): List<UserAndLibrary>
Java
@Transaction @Query("SELECT * FROM User") public List<UserAndLibrary> getUsersAndLibraries();
वन-टू-मेनी रिलेशनशिप को परिभाषित करना
दो इकाइयों के बीच वन-टू-मेनी रिलेशनशिप एक ऐसा संबंध होता है जिसमें दोनों पैरंट इकाई का इंस्टेंस, चाइल्ड के शून्य या उससे ज़्यादा इंस्टेंस से मेल खाता है इकाई है, लेकिन चाइल्ड इकाई का हर इंस्टेंस सिर्फ़ एक से मैच हो सकता है पैरंट इकाई का इंस्टेंस.
संगीत स्ट्रीमिंग ऐप्लिकेशन के उदाहरण में, मान लें कि उपयोगकर्ता
अपने गानों की प्लेलिस्ट बनाना. हर व्यक्ति जितनी चाहें उतनी प्लेलिस्ट बना सकता है,
लेकिन हर प्लेलिस्ट सिर्फ़ एक उपयोगकर्ता ने बनाई है. इसलिए,
User
इकाई और Playlist
इकाई के बीच वन-टू-मेनी संबंध.
वन-टू-मेनी संबंध तय करने के लिए, पहले दोनों इकाइयों के लिए एक क्लास बनाएं. एक-से-एक संबंध की तरह, चाइल्ड इकाई में एक ऐसा वैरिएबल शामिल होना चाहिए जो पैरंट इकाई की मुख्य कुंजी का रेफ़रंस है.
Kotlin
@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 )
Java
@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
चाइल्ड इकाई के कॉलम के नाम पर सेट करें, जो पैरंट का रेफ़रंस देता है
इकाई की प्राथमिक कुंजी है.
Kotlin
data class UserWithPlaylists( @Embedded val user: User, @Relation( parentColumn = "userId", entityColumn = "userCreatorId" ) val playlists: List<Playlist> )
Java
public class UserWithPlaylists { @Embedded public User user; @Relation( parentColumn = "userId", entityColumn = "userCreatorId" ) public List<Playlist> playlists; }
आखिर में, डीएओ क्लास में ऐसा तरीका जोड़ें जो डेटा के सभी इंस्टेंस दिखाता हो
क्लास, जो पैरंट इकाई और चाइल्ड इकाई को जोड़ती है. इस तरीके का इस्तेमाल करने के लिए, यह ज़रूरी है
दो क्वेरी चलाने के लिए कमरा, इसलिए इसमें @Transaction
एनोटेशन जोड़ें
तरीका है, ताकि पूरा काम अपने तरीके से हो.
Kotlin
@Transaction @Query("SELECT * FROM User") fun getUsersWithPlaylists(): List<UserWithPlaylists>
Java
@Transaction @Query("SELECT * FROM User") public List<UserWithPlaylists> getUsersWithPlaylists();
मेनी-टू-मेनी संबंध तय करना
दो इकाइयों के बीच मेनी-टू-मेनी रिलेशनशिप ऐसा संबंध होता है जिसमें दोनों पैरंट इकाई का इंस्टेंस, चाइल्ड के शून्य या उससे ज़्यादा इंस्टेंस से मेल खाता है इकाई है और उलटा भी सही है.
संगीत स्ट्रीमिंग ऐप्लिकेशन के उदाहरण में, लोगों की बनाई हुई प्लेलिस्ट में मौजूद गानों पर ध्यान दें.
हर प्लेलिस्ट में कई गाने हो सकते हैं. साथ ही, हर गाना कई गानों का हिस्सा हो सकता है
अलग-अलग प्लेलिस्ट का इस्तेमाल करें. इसलिए, एक ऐसा संबंध है
Playlist
एंटिटी और Song
एंटिटी के बीच में.
मेनी-टू-मेनी संबंध तय करने के लिए, पहले अपने दोनों में से हर एक के लिए क्लास बनाएं
इकाइयां. मेनी-टू-मेनी रिलेशनशिप
अन्य संबंध से अलग होते हैं, क्योंकि आम तौर पर ऐसा कोई
चाइल्ड इकाई में पैरंट इकाई का रेफ़रंस. इसके बजाय, तीसरा सेगमेंट बनाएं
क्लास का इस्तेमाल किसी असोसिएशन इकाई या क्रॉस-रेफ़रंस
टेबल, दो इकाइयों के बीच में होती है. क्रॉस-रेफ़रंस टेबल में
प्राथमिक कुंजी, जिसमें मौजूद मेनी-टू-मेनी संबंध में प्रत्येक इकाई की
टेबल. इस उदाहरण में, क्रॉस-रेफ़रंस टेबल की हर पंक्ति
Playlist
इंस्टेंस और Song
इंस्टेंस का पेयरिंग जहां रेफ़रंस दिया गया हो
पहचानी गई प्लेलिस्ट में गाना शामिल होना चाहिए.
Kotlin
@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 )
Java
@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
इकाई के बीच.
Kotlin
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> )
Java
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
दोनों तरीकों से एनोटेशन बनाएं, ताकि पूरा
काम उसी तरीके से किया जाता है.
Kotlin
@Transaction @Query("SELECT * FROM Playlist") fun getPlaylistsWithSongs(): List<PlaylistWithSongs> @Transaction @Query("SELECT * FROM Song") fun getSongsWithPlaylists(): List<SongWithPlaylists>
Java
@Transaction @Query("SELECT * FROM Playlist") public List<PlaylistWithSongs> getPlaylistsWithSongs(); @Transaction @Query("SELECT * FROM Song") public List<SongWithPlaylists> getSongsWithPlaylists();
नेस्ट किए गए संबंधों को तय करना
कभी-कभी, आपको तीन या उससे ज़्यादा ऐसी टेबल के सेट के लिए क्वेरी करनी पड़ सकती है जिनमें सभी एक-दूसरे से संबंधित होते हैं. इस मामले में, नेस्ट किए गए रिलेशनशिप टेबल के बीच में रखें.
मान लें कि संगीत स्ट्रीमिंग ऐप्लिकेशन के उदाहरण में, आपको उपयोगकर्ता, हर उपयोगकर्ता की सभी प्लेलिस्ट, और हर प्लेलिस्ट में मौजूद सभी गाने एक ही उपयोगकर्ता नाम का इस्तेमाल करें. उपयोगकर्ताओं का वन-टू-मेनी रिलेशनशिप होना ज़रूरी है प्लेलिस्ट, और प्लेलिस्ट के कई-से-कई लोगों का जुड़ाव होता है गाने. नीचे दिया गया उदाहरण कोड इन क्लास को दिखाता है इकाइयों और क्रॉस-रेफ़रंस टेबल के लिए, कई-से-मेनी रिलेशनशिप प्लेलिस्ट और गानों के बीच में बदलाव करें:
Kotlin
@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 )
Java
@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
इकाई क्लास के बीच संबंध:
Kotlin
data class PlaylistWithSongs( @Embedded val playlist: Playlist, @Relation( parentColumn = "playlistId", entityColumn = "songId", associateBy = Junction(PlaylistSongCrossRef::class) ) val songs: List<Song> )
Java
public class PlaylistWithSongs { @Embedded public Playlist playlist; @Relation( parentColumn = "playlistId", entityColumn = "songId", associateBy = Junction(PlaylistSongCrossRef.class) ) public List<Song> songs; }
इस संबंध को दिखाने वाली डेटा क्लास के बारे में बताने के बाद, दूसरा बनाएं
वह डेटा क्लास जो आपके सेट और आपके सेट की किसी अन्य टेबल के बीच के संबंध का मॉडल तैयार करती है
फ़र्स्ट रिलेशनशिप क्लास, "नेस्टिंग" नए कानून के साथ मौजूदा संबंध
एक. इस उदाहरण में, UserWithPlaylistsAndSongs
क्लास के बारे में बताया गया है, जो
User
इकाई क्लास और
PlaylistWithSongs
संबंध श्रेणी:
Kotlin
data class UserWithPlaylistsAndSongs( @Embedded val user: User @Relation( entity = Playlist::class, parentColumn = "userId", entityColumn = "userCreatorId" ) val playlists: List<PlaylistWithSongs> )
Java
public class UserWithPlaylistsAndSongs { @Embedded public User user; @Relation( entity = Playlist.class, parentColumn = "userId", entityColumn = "userCreatorId" ) public List<PlaylistWithSongs> playlists; }
UserWithPlaylistsAndSongs
क्लास सीधे तौर पर, रिलेशनशिप को मॉडल करती है
इकाई की तीनों क्लास के बीच में: User
, Playlist
, और Song
. यह है
पहली इमेज में दिखाया गया है.
![UserWithPLAYLISTAndSongs, उपयोगकर्ता और पार्टनर के बीच के संबंध को दिखाता है
PlaylistWithSongs, जो प्लेलिस्ट के बीच के रिश्ते को दिखाती है
और गाना शामिल करें.](https://developer.android.com/static/images/training/data-storage/room_nested_relationships.png?authuser=9&hl=hi)
पहला डायग्राम. इस डायग्राम में संबंध वर्गों का डायग्राम संगीत स्ट्रीमिंग ऐप्लिकेशन का उदाहरण.
अगर आपके सेट में और टेबल हैं, तो बची हुई हर टेबल और उस रिलेशनशिप क्लास के बीच संबंध जो मॉडल करती है पिछली सभी टेबल के बीच का संबंध. इससे नेस्ट की गई एक चेन कई टेबल के बीच के संबंधों को दिखाया जाता है.
आखिर में, डीएओ क्लास में एक तरीका जोड़ें, ताकि क्वेरी फ़ंक्शन का पता चल सके जो
आपके ऐप्लिकेशन की ज़रूरतें पूरी होती हैं. इस तरीके में एक से ज़्यादा क्वेरी चलाने के लिए रूम की ज़रूरत होती है, इसलिए
@Transaction
एनोटेशन
इससे पूरा काम अपने तरीके से होता है:
Kotlin
@Transaction @Query("SELECT * FROM User") fun getUsersWithPlaylistsAndSongs(): List<UserWithPlaylistsAndSongs>
Java
@Transaction @Query("SELECT * FROM User") public List<UserWithPlaylistsAndSongs> getUsersWithPlaylistsAndSongs();
अन्य संसाधन
रूम में इकाइयों के बीच संबंध तय करने के बारे में ज़्यादा जानने के लिए, यहां देखें: इन अतिरिक्त संसाधनों को देखें.
सैंपल
वीडियो
- रूम में नया क्या है (Android Dev सम्मेलन '19)