Définir et interroger des relations imbriquées

Vous pouvez parfois avoir besoin d'interroger un ensemble de trois tableaux ou plus, tous liés les uns aux autres. Dans ce cas, définissez des relations imbriquées entre les tableaux.

Supposons que, dans notre application de streaming musical, vous souhaitiez interroger tous les utilisateurs, toutes les playlists de chaque utilisateur et tous les titres de chaque playlist de chaque utilisateur. Les utilisateurs sont liés par une relation de type un à plusieurs aux playlists, et les playlists sont elles-mêmes liées par une relation de type plusieurs à plusieurs avec les titres. L'exemple de code suivant montre les classes qui représentent ces entités, ainsi que le tableau de concordance pour la relation de type plusieurs à plusieurs entre les playlists et les titres :

@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

Tout d'abord, représentez la relation entre deux des tableaux de votre ensemble comme vous le feriez normalement, avec une classe de données et l'@Relation annotation. L'exemple suivant montre une classe PlaylistWithSongs qui représente une relation de type plusieurs à plusieurs entre la classe d'entités Playlist et la classe d'entités Song :

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

Après avoir défini une classe de données représentant cette relation, créez une autre classe de données qui représente la relation entre un autre tableau de votre ensemble et la première classe de la relation, en "imbriquant" la relation existante dans la nouvelle. L'exemple suivant montre une classe UserWithPlaylistsAndSongs qui représente une relation de type un à plusieurs entre la classe d'entités User et la PlaylistWithSongs classe de relation :

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

La classe UserWithPlaylistsAndSongs représente de manière indirecte les relations entre les trois classes d'entités : User, Playlist, et Song. C'est ce qu'illustre l'image 1.

Si votre ensemble compte d'autres tableaux, créez une classe permettant de représenter la relation entre chaque tableau restant et la classe de relation précédente. Ce processus crée une chaîne de relations imbriquées entre tous les tableaux que vous souhaitez interroger.

Enfin, ajoutez une fonction à la classe d'objet d'accès aux données (DAO) pour afficher la fonction de requête nécessaire à votre application. Cette fonction nécessite que Room exécute plusieurs requêtes. Vous devez donc ajouter l'annotation @Transaction pour vous assurer que toute l'opération est effectuée de manière atomique :

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