नेस्ट की गई रिलेशनशिप

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

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

@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. इसकी जानकारी, पहले चित्र में दी गई है.

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

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

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

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