Verschachtelte Beziehungen definieren und abfragen

Manchmal müssen Sie möglicherweise eine Reihe von 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 im Beispiel der Musikstreaming-App alle Nutzer, alle Playlists für jeden Nutzer und alle Songs in jeder Playlist für jeden Nutzer abfragen. Nutzer haben eine 1:n-Beziehung zu Playlists und Playlists haben eine n:m-Beziehung zu Songs. Das folgende Codebeispiel zeigt die Klassen, die diese Entitäten darstellen, sowie die Querverweistabelle für die n:m-Beziehung 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"], indices = [Index("playlistId", "songId")])
data class PlaylistSongCrossRef(
    val playlistId: Long,
    val songId: Long
)

Modellieren Sie zuerst die Beziehung zwischen zwei der Tabellen in Ihrem Set wie Sie normalerweise tun, mit einer Datenklasse und der @Relation Annotation. 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(
        parentColumns = ["playlistId"],
        entityColumns = ["songId"],
        associateBy = Junction(PlaylistSongCrossRef::class)
    )
    val songs: List<Song>
)

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

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

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

Das Modell „UserWithPlaylistsAndSongs“ bildet die Beziehung zwischen „User“ und „PlaylistWithSongs“ ab, die wiederum die Beziehung zwischen „Playlist“ und „Song“ abbildet.
Abbildung 1. Diagramm der Beziehungsklassen im Beispiel der Musikstreaming-App.

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

Fügen Sie schließlich der Klasse des Data Access Object (DAO) eine Funktion hinzu, um die Abfragefunktion verfügbar zu machen, die Ihre App benötigt. Für diese Funktion müssen mehrere Abfragen ausgeführt werden. Fügen Sie daher die @Transaction Annotation hinzu, damit der ganze Vorgang atomar ausgeführt wird:

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