Definire e eseguire query sulle relazioni nidificate

A volte, potresti dover eseguire una query su un insieme di tre o più tabelle correlate tra loro. In questo caso, definisci relazioni nidificate tra le tabelle.

Supponiamo che nell'esempio dell'app di streaming musicale tu voglia eseguire una query su tutti gli utenti, tutte le playlist di ogni utente e tutti i brani di ogni playlist per ogni utente. Gli utenti hanno una relazione uno-a-molti con le playlist e le playlist hanno una relazione molti-a-molti con i brani. L'esempio di codice seguente mostra le classi che rappresentano queste entità, nonché la tabella di riferimenti incrociati per la relazione molti-a-molti tra playlist e brani:

@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"], indices = [Index("playlistId", "songId")])
data class PlaylistSongCrossRef(
    val playlistId: Long,
    val songId: Long
)
NestedRelationshipsSnippets.kt

Innanzitutto, modella la relazione tra due delle tabelle dell'insieme come faresti normalmente, utilizzando una classe di dati e l'annotazione @Relation. L' esempio seguente mostra una classe PlaylistWithSongs che modella una relazione molti-a-molti tra la classe di entità Playlist e la classe di entità Song:

data class PlaylistWithSongs(
    @Embedded val playlist: Playlist,
    @Relation(
        parentColumns = ["playlistId"],
        entityColumns = ["songId"],
        associateBy = Junction(PlaylistSongCrossRef::class)
    )
    val songs: List<Song>
)
NestedRelationshipsSnippets.kt

Dopo aver definito una classe di dati che rappresenta questa relazione, crea un'altra classe di dati che modelli la relazione tra un'altra tabella dell'insieme e la prima classe di relazione, "nidificando" la relazione esistente all'interno della nuova. L'esempio seguente mostra una classe UserWithPlaylistsAndSongs che modella una relazione uno-a-molti tra la classe di entità User e la PlaylistWithSongs classe di relazione:

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

La classe UserWithPlaylistsAndSongs modella indirettamente le relazioni tra tutte e tre le classi di entità: User, Playlist, e Song. Questo è illustrato nella Figura 1.

Se l'insieme contiene più tabelle, crea una classe per modellare la relazione tra ogni tabella rimanente e la classe di relazione precedente. Questo processo crea una catena di relazioni nidificate tra tutte le tabelle su cui vuoi eseguire query.

Infine, aggiungi una funzione alla classe Data Access Object (DAO) per esporre la funzione di query di cui ha bisogno la tua app. Questa funzione richiede a Room di eseguire più query, quindi aggiungi l'annotazione @Transaction in modo che l'intera operazione venga eseguita in modo atomico:

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