Verschachtelte Beziehungen

Manchmal müssen Sie drei oder mehr Tabellen abfragen, die alle miteinander in Beziehung stehen. In diesem Fall definieren Sie verschachtelte Beziehungen zwischen den Tabellen.

Angenommen, Sie möchten in der Beispiel-Musik-Streaming-App alle Nutzer, alle Playlists für jeden Nutzer und alle Titel in jeder Playlist für jeden Nutzer abfragen. Nutzer stehen in einer 1:n-Beziehung zu Playlists und Playlists stehen in einer m:n-Beziehung zu Songs. Das folgende Codebeispiel zeigt die Klassen, die diese Entitäten repräsentieren, sowie die Verweistabelle für die Beziehung „Mehrfach zueinander“ zwischen Playlists und Songs:

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

Modellieren Sie zuerst die Beziehung zwischen zwei Tabellen in Ihrem Set wie gewohnt mit einer Datenklasse und der Anmerkung @Relation. Das folgende Beispiel zeigt eine PlaylistWithSongs-Klasse, die eine n:m-Beziehung zwischen der Entitätsklasse Playlist und der Entitätsklasse Song modelliert:

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

Nachdem Sie eine Datenklasse definiert haben, die diese Beziehung darstellt, erstellen Sie eine weitere Datenklasse, die die Beziehung zwischen einer anderen Tabelle aus Ihrem Satz und der ersten Beziehungsklasse modelliert. Dabei wird die vorhandene Beziehung in die neue verschachtelt. Das folgende Beispiel zeigt eine UserWithPlaylistsAndSongs-Klasse, die eine 1:n-Beziehung zwischen der Entitätsklasse User und der Beziehungsklasse PlaylistWithSongs modelliert:

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

Die Klasse UserWithPlaylistsAndSongs modelliert indirekt die Beziehungen zwischen allen drei Entitätsklassen: User, Playlist und Song. Das ist in Abbildung 1 dargestellt.

Wenn Ihre Gruppe weitere Tabellen enthält, erstellen Sie eine Klasse, um die Beziehung zwischen jeder verbleibenden Tabelle und der Beziehungsklasse zu modellieren, die die Beziehungen zwischen allen vorherigen Tabellen modelliert. Dadurch wird eine Kette verschachtelter Beziehungen zwischen allen Tabellen erstellt, die Sie abfragen möchten.

Fügen Sie der DAO-Klasse abschließend eine Methode hinzu, um die Abfragefunktion für Ihre App freizugeben. Für diese Methode muss Room mehrere Abfragen ausführen. Fügen Sie daher die Anmerkung @Transaction hinzu, damit der gesamte Vorgang atomar ausgeführt wird:

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

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