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, vous 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, qui 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"])
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;
}

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'annotation @Relation. 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(
         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;
}

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 classe de relation 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;
}

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 qui représente les relations entre tous les tableaux précédents. Cette opération crée une chaîne de relations imbriquées entre tous les tableaux que vous souhaitez interroger.

Enfin, ajoutez une méthode à la classe DAO pour afficher la fonction de requête nécessaire à votre application. Cette méthode 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")
fun getUsersWithPlaylistsAndSongs(): List<UserWithPlaylistsAndSongs>

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