Relazioni nidificate

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

Attenzione: l'esecuzione di query sui dati con relazioni nidificate richiede che Room manipoli un gran volume di dati e può influire sulle prestazioni. Utilizza il minor numero possibile di relazioni nidificate nelle query.

Supponiamo che nell'esempio dell'app di streaming musicale tu voglia eseguire query su tutti gli utenti, su tutte le playlist di ciascun utente e su tutti i brani di ogni playlist di ciascun utente. Gli utenti hanno una relazione uno-a-molti con le playlist, mentre le playlist hanno una relazione many-to-many con i brani. L'esempio di codice riportato di seguito mostra le classi che rappresentano queste entità, nonché la tabella di riferimento incrociato 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 del set come faresti normalmente, utilizzando una classe di dati e l'annotazione @Relation. L'esempio seguente mostra una classe PlaylistWithSongs che modella una relazione many-to-many 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 modelli la relazione tra un'altra tabella del set 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 one-to-many tra la classe di entità User e la classe di relazione PlaylistWithSongs:

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 tutti e tre i tipi di entità: User, Playlist e Song. Come illustrato nella figura 1.

Figura 1. Diagramma delle classi di relazione nell'esempio di app di streaming di musica.

Se il set contiene 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. 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'annotazione @Transaction 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();