Definire e eseguire query sulle relazioni nidificate

A volte, potresti dover eseguire 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 query su tutti gli utenti, su tutte le playlist di ogni utente e su 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:

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;
}

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:

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;
}

Dopo aver definito una classe di dati che rappresenta questa relazione, crea un'altra classe di dati che modella 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:

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;
}

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

UserWithPlaylistsAndSongs modella la relazione tra User e PlaylistWithSongs, che a sua volta modella la relazione tra Playlist e Song.
Figura 1. Diagramma delle classi di relazione nell' esempio dell'app di streaming musicale.

Se nell'insieme sono presenti altre tabelle, crea una classe per modellare la relazione tra ogni tabella rimanente e la classe di relazione che modella le relazioni tra tutte le tabelle precedenti. In questo modo, viene creata una catena di relazioni nidificate tra tutte le tabelle su cui vuoi eseguire query.

Infine, aggiungi un metodo alla classe DAO per esporre la funzione di query di cui ha bisogno la tua app. Questo metodo richiede a Room di eseguire più query, quindi aggiungi l' @Transaction annotazione in modo che l'intera operazione venga eseguita in modo atomico:

Kotlin

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

Java

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